Client Test

Client Test

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05

Files changed:

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/protocol_serde/shape_greeting_with_errors.rs

@@ -2,2 +91,85 @@
   22     22   
        "InvalidGreeting" => crate::operation::greeting_with_errors::GreetingWithErrorsError::InvalidGreeting({
   23     23   
            #[allow(unused_mut)]
   24     24   
            let mut tmp = {
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut output = crate::types::error::builders::InvalidGreetingBuilder::default();
   27     27   
                output = crate::protocol_serde::shape_invalid_greeting::de_invalid_greeting_xml_err(_response_body, output)
   28     28   
                    .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
   29     29   
                let output = output.meta(generic);
   30     30   
                output.build()
   31     31   
            };
   32         -
            if tmp.message.is_none() {
   33         -
                tmp.message = _error_message;
   34         -
            }
   35     32   
            tmp
   36     33   
        }),
   37     34   
        "ComplexError" => crate::operation::greeting_with_errors::GreetingWithErrorsError::ComplexError({
   38     35   
            #[allow(unused_mut)]
   39     36   
            let mut tmp = {
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut output = crate::types::error::builders::ComplexErrorBuilder::default();
   42     39   
                output = crate::protocol_serde::shape_complex_error::de_complex_error_xml_err(_response_body, output)
   43     40   
                    .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
   44     41   
                let output = output.meta(generic);
   45     42   
                output.build()
   46     43   
            };
   47     44   
            tmp
   48     45   
        }),
   49     46   
        "Customized" => crate::operation::greeting_with_errors::GreetingWithErrorsError::CustomCodeError({
   50     47   
            #[allow(unused_mut)]
   51     48   
            let mut tmp = {
   52     49   
                #[allow(unused_mut)]
   53     50   
                let mut output = crate::types::error::builders::CustomCodeErrorBuilder::default();
   54     51   
                output = crate::protocol_serde::shape_custom_code_error::de_custom_code_error_xml_err(_response_body, output)
   55     52   
                    .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
   56     53   
                let output = output.meta(generic);
   57     54   
                output.build()
   58     55   
            };
   59         -
            if tmp.message.is_none() {
   60         -
                tmp.message = _error_message;
   61         -
            }
   62     56   
            tmp
   63     57   
        }),
   64     58   
        _ => crate::operation::greeting_with_errors::GreetingWithErrorsError::generic(generic),
   65     59   
    })
   66     60   
}
   67     61   
   68     62   
#[allow(clippy::unnecessary_wraps)]
   69     63   
pub fn de_greeting_with_errors_http_response(
   70     64   
    _response_status: u16,
   71     65   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/types/_complex_nested_error_data.rs

@@ -1,1 +44,55 @@
    5      5   
pub struct ComplexNestedErrorData {
    6      6   
    #[allow(missing_docs)] // documentation missing in model
    7      7   
    pub foo: ::std::option::Option<::std::string::String>,
    8      8   
}
    9      9   
impl ComplexNestedErrorData {
   10     10   
    #[allow(missing_docs)] // documentation missing in model
   11     11   
    pub fn foo(&self) -> ::std::option::Option<&str> {
   12     12   
        self.foo.as_deref()
   13     13   
    }
   14     14   
}
          15  +
impl ::std::fmt::Display for ComplexNestedErrorData {
          16  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          17  +
        ::std::write!(f, "ComplexNestedErrorData {{")?;
          18  +
        if let ::std::option::Option::Some(inner) = &self.foo {
          19  +
            ::std::write!(f, "foo=Some({})", inner)?;
          20  +
        } else {
          21  +
            ::std::write!(f, "foo=None")?;
          22  +
        }
          23  +
        ::std::write!(f, "}}")
          24  +
    }
          25  +
}
   15     26   
impl ComplexNestedErrorData {
   16     27   
    /// Creates a new builder-style object to manufacture [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
   17     28   
    pub fn builder() -> crate::types::builders::ComplexNestedErrorDataBuilder {
   18     29   
        crate::types::builders::ComplexNestedErrorDataBuilder::default()
   19     30   
    }
   20     31   
}
   21     32   
   22     33   
/// A builder for [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
   23     34   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   24     35   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_batch_execute_statement.rs

@@ -2,2 +79,73 @@
   22     22   
        "InternalServerError" => crate::operation::batch_execute_statement::BatchExecuteStatementError::InternalServerError({
   23     23   
            #[allow(unused_mut)]
   24     24   
            let mut tmp = {
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   27     27   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   28     28   
                    .map_err(crate::operation::batch_execute_statement::BatchExecuteStatementError::unhandled)?;
   29     29   
                let output = output.meta(generic);
   30     30   
                output.build()
   31     31   
            };
   32         -
            if tmp.message.is_none() {
   33         -
                tmp.message = _error_message;
   34         -
            }
   35     32   
            tmp
   36     33   
        }),
   37     34   
        "RequestLimitExceeded" => crate::operation::batch_execute_statement::BatchExecuteStatementError::RequestLimitExceeded({
   38     35   
            #[allow(unused_mut)]
   39     36   
            let mut tmp = {
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
   42     39   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
   43     40   
                    .map_err(crate::operation::batch_execute_statement::BatchExecuteStatementError::unhandled)?;
   44     41   
                let output = output.meta(generic);
   45     42   
                output.build()
   46     43   
            };
   47         -
            if tmp.message.is_none() {
   48         -
                tmp.message = _error_message;
   49         -
            }
   50     44   
            tmp
   51     45   
        }),
   52     46   
        _ => crate::operation::batch_execute_statement::BatchExecuteStatementError::generic(generic),
   53     47   
    })
   54     48   
}
   55     49   
   56     50   
#[allow(clippy::unnecessary_wraps)]
   57     51   
pub fn de_batch_execute_statement_http_response(
   58     52   
    _response_status: u16,
   59     53   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_batch_get_item.rs

@@ -1,1 +122,107 @@
   19     19   
        "InternalServerError" => crate::operation::batch_get_item::BatchGetItemError::InternalServerError({
   20     20   
            #[allow(unused_mut)]
   21     21   
            let mut tmp = {
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   25     25   
                    .map_err(crate::operation::batch_get_item::BatchGetItemError::unhandled)?;
   26     26   
                let output = output.meta(generic);
   27     27   
                output.build()
   28     28   
            };
   29         -
            if tmp.message.is_none() {
   30         -
                tmp.message = _error_message;
   31         -
            }
   32     29   
            tmp
   33     30   
        }),
   34     31   
        "InvalidEndpointException" => crate::operation::batch_get_item::BatchGetItemError::InvalidEndpointError({
   35     32   
            #[allow(unused_mut)]
   36     33   
            let mut tmp = {
   37     34   
                #[allow(unused_mut)]
   38     35   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   39     36   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   40     37   
                    .map_err(crate::operation::batch_get_item::BatchGetItemError::unhandled)?;
   41     38   
                let output = output.meta(generic);
   42     39   
                output.build()
   43     40   
            };
   44         -
            if tmp.message.is_none() {
   45         -
                tmp.message = _error_message;
   46         -
            }
   47     41   
            tmp
   48     42   
        }),
   49     43   
        "ProvisionedThroughputExceededException" => {
   50     44   
            crate::operation::batch_get_item::BatchGetItemError::ProvisionedThroughputExceededError({
   51     45   
                #[allow(unused_mut)]
   52     46   
                let mut tmp = {
   53     47   
                    #[allow(unused_mut)]
   54     48   
                    let mut output = crate::types::error::builders::ProvisionedThroughputExceededErrorBuilder::default();
   55     49   
                    output = crate::protocol_serde::shape_provisioned_throughput_exceeded_exception::de_provisioned_throughput_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::batch_get_item::BatchGetItemError::unhandled)?;
   56     50   
                    let output = output.meta(generic);
   57     51   
                    output.build()
   58     52   
                };
   59         -
                if tmp.message.is_none() {
   60         -
                    tmp.message = _error_message;
   61         -
                }
   62     53   
                tmp
   63     54   
            })
   64     55   
        }
   65     56   
        "RequestLimitExceeded" => crate::operation::batch_get_item::BatchGetItemError::RequestLimitExceeded({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::batch_get_item::BatchGetItemError::unhandled)?;
   72     63   
                let output = output.meta(generic);
   73     64   
                output.build()
   74     65   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     66   
            tmp
   79     67   
        }),
   80     68   
        "ResourceNotFoundException" => crate::operation::batch_get_item::BatchGetItemError::ResourceNotFoundError({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::batch_get_item::BatchGetItemError::unhandled)?;
   87     75   
                let output = output.meta(generic);
   88     76   
                output.build()
   89     77   
            };
   90         -
            if tmp.message.is_none() {
   91         -
                tmp.message = _error_message;
   92         -
            }
   93     78   
            tmp
   94     79   
        }),
   95     80   
        _ => crate::operation::batch_get_item::BatchGetItemError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_batch_get_item_http_response(
  101     86   
    _response_status: u16,
  102     87   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_batch_write_item.rs

@@ -1,1 +138,120 @@
   19     19   
        "InternalServerError" => crate::operation::batch_write_item::BatchWriteItemError::InternalServerError({
   20     20   
            #[allow(unused_mut)]
   21     21   
            let mut tmp = {
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   25     25   
                    .map_err(crate::operation::batch_write_item::BatchWriteItemError::unhandled)?;
   26     26   
                let output = output.meta(generic);
   27     27   
                output.build()
   28     28   
            };
   29         -
            if tmp.message.is_none() {
   30         -
                tmp.message = _error_message;
   31         -
            }
   32     29   
            tmp
   33     30   
        }),
   34     31   
        "InvalidEndpointException" => crate::operation::batch_write_item::BatchWriteItemError::InvalidEndpointError({
   35     32   
            #[allow(unused_mut)]
   36     33   
            let mut tmp = {
   37     34   
                #[allow(unused_mut)]
   38     35   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   39     36   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   40     37   
                    .map_err(crate::operation::batch_write_item::BatchWriteItemError::unhandled)?;
   41     38   
                let output = output.meta(generic);
   42     39   
                output.build()
   43     40   
            };
   44         -
            if tmp.message.is_none() {
   45         -
                tmp.message = _error_message;
   46         -
            }
   47     41   
            tmp
   48     42   
        }),
   49     43   
        "ItemCollectionSizeLimitExceededException" => {
   50     44   
            crate::operation::batch_write_item::BatchWriteItemError::ItemCollectionSizeLimitExceededError({
   51     45   
                #[allow(unused_mut)]
   52     46   
                let mut tmp = {
   53     47   
                    #[allow(unused_mut)]
   54     48   
                    let mut output = crate::types::error::builders::ItemCollectionSizeLimitExceededErrorBuilder::default();
   55     49   
                    output = crate::protocol_serde::shape_item_collection_size_limit_exceeded_exception::de_item_collection_size_limit_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::batch_write_item::BatchWriteItemError::unhandled)?;
   56     50   
                    let output = output.meta(generic);
   57     51   
                    output.build()
   58     52   
                };
   59         -
                if tmp.message.is_none() {
   60         -
                    tmp.message = _error_message;
   61         -
                }
   62     53   
                tmp
   63     54   
            })
   64     55   
        }
   65     56   
        "ProvisionedThroughputExceededException" => {
   66     57   
            crate::operation::batch_write_item::BatchWriteItemError::ProvisionedThroughputExceededError({
   67     58   
                #[allow(unused_mut)]
   68     59   
                let mut tmp = {
   69     60   
                    #[allow(unused_mut)]
   70     61   
                    let mut output = crate::types::error::builders::ProvisionedThroughputExceededErrorBuilder::default();
   71     62   
                    output = crate::protocol_serde::shape_provisioned_throughput_exceeded_exception::de_provisioned_throughput_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::batch_write_item::BatchWriteItemError::unhandled)?;
   72     63   
                    let output = output.meta(generic);
   73     64   
                    output.build()
   74     65   
                };
   75         -
                if tmp.message.is_none() {
   76         -
                    tmp.message = _error_message;
   77         -
                }
   78     66   
                tmp
   79     67   
            })
   80     68   
        }
   81     69   
        "RequestLimitExceeded" => crate::operation::batch_write_item::BatchWriteItemError::RequestLimitExceeded({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
   87     75   
                    .map_err(crate::operation::batch_write_item::BatchWriteItemError::unhandled)?;
   88     76   
                let output = output.meta(generic);
   89     77   
                output.build()
   90     78   
            };
   91         -
            if tmp.message.is_none() {
   92         -
                tmp.message = _error_message;
   93         -
            }
   94     79   
            tmp
   95     80   
        }),
   96     81   
        "ResourceNotFoundException" => crate::operation::batch_write_item::BatchWriteItemError::ResourceNotFoundError({
   97     82   
            #[allow(unused_mut)]
   98     83   
            let mut tmp = {
   99     84   
                #[allow(unused_mut)]
  100     85   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
  101     86   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  102     87   
                    .map_err(crate::operation::batch_write_item::BatchWriteItemError::unhandled)?;
  103     88   
                let output = output.meta(generic);
  104     89   
                output.build()
  105     90   
            };
  106         -
            if tmp.message.is_none() {
  107         -
                tmp.message = _error_message;
  108         -
            }
  109     91   
            tmp
  110     92   
        }),
  111     93   
        _ => crate::operation::batch_write_item::BatchWriteItemError::generic(generic),
  112     94   
    })
  113     95   
}
  114     96   
  115     97   
#[allow(clippy::unnecessary_wraps)]
  116     98   
pub fn de_batch_write_item_http_response(
  117     99   
    _response_status: u16,
  118    100   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_create_backup.rs

@@ -1,1 +154,133 @@
   19     19   
        "BackupInUseException" => crate::operation::create_backup::CreateBackupError::BackupInUseError({
   20     20   
            #[allow(unused_mut)]
   21     21   
            let mut tmp = {
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::BackupInUseErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_backup_in_use_exception::de_backup_in_use_exception_json_err(_response_body, output)
   25     25   
                    .map_err(crate::operation::create_backup::CreateBackupError::unhandled)?;
   26     26   
                let output = output.meta(generic);
   27     27   
                output.build()
   28     28   
            };
   29         -
            if tmp.message.is_none() {
   30         -
                tmp.message = _error_message;
   31         -
            }
   32     29   
            tmp
   33     30   
        }),
   34     31   
        "ContinuousBackupsUnavailableException" => crate::operation::create_backup::CreateBackupError::ContinuousBackupsUnavailableError({
   35     32   
            #[allow(unused_mut)]
   36     33   
            let mut tmp = {
   37     34   
                #[allow(unused_mut)]
   38     35   
                let mut output = crate::types::error::builders::ContinuousBackupsUnavailableErrorBuilder::default();
   39     36   
                output = crate::protocol_serde::shape_continuous_backups_unavailable_exception::de_continuous_backups_unavailable_exception_json_err(
   40     37   
                    _response_body,
   41     38   
                    output,
   42     39   
                )
   43     40   
                .map_err(crate::operation::create_backup::CreateBackupError::unhandled)?;
   44     41   
                let output = output.meta(generic);
   45     42   
                output.build()
   46     43   
            };
   47         -
            if tmp.message.is_none() {
   48         -
                tmp.message = _error_message;
   49         -
            }
   50     44   
            tmp
   51     45   
        }),
   52     46   
        "InternalServerError" => crate::operation::create_backup::CreateBackupError::InternalServerError({
   53     47   
            #[allow(unused_mut)]
   54     48   
            let mut tmp = {
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   57     51   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   58     52   
                    .map_err(crate::operation::create_backup::CreateBackupError::unhandled)?;
   59     53   
                let output = output.meta(generic);
   60     54   
                output.build()
   61     55   
            };
   62         -
            if tmp.message.is_none() {
   63         -
                tmp.message = _error_message;
   64         -
            }
   65     56   
            tmp
   66     57   
        }),
   67     58   
        "InvalidEndpointException" => crate::operation::create_backup::CreateBackupError::InvalidEndpointError({
   68     59   
            #[allow(unused_mut)]
   69     60   
            let mut tmp = {
   70     61   
                #[allow(unused_mut)]
   71     62   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   72     63   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   73     64   
                    .map_err(crate::operation::create_backup::CreateBackupError::unhandled)?;
   74     65   
                let output = output.meta(generic);
   75     66   
                output.build()
   76     67   
            };
   77         -
            if tmp.message.is_none() {
   78         -
                tmp.message = _error_message;
   79         -
            }
   80     68   
            tmp
   81     69   
        }),
   82     70   
        "LimitExceededException" => crate::operation::create_backup::CreateBackupError::LimitExceededError({
   83     71   
            #[allow(unused_mut)]
   84     72   
            let mut tmp = {
   85     73   
                #[allow(unused_mut)]
   86     74   
                let mut output = crate::types::error::builders::LimitExceededErrorBuilder::default();
   87     75   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   88     76   
                    .map_err(crate::operation::create_backup::CreateBackupError::unhandled)?;
   89     77   
                let output = output.meta(generic);
   90     78   
                output.build()
   91     79   
            };
   92         -
            if tmp.message.is_none() {
   93         -
                tmp.message = _error_message;
   94         -
            }
   95     80   
            tmp
   96     81   
        }),
   97     82   
        "TableInUseException" => crate::operation::create_backup::CreateBackupError::TableInUseError({
   98     83   
            #[allow(unused_mut)]
   99     84   
            let mut tmp = {
  100     85   
                #[allow(unused_mut)]
  101     86   
                let mut output = crate::types::error::builders::TableInUseErrorBuilder::default();
  102     87   
                output = crate::protocol_serde::shape_table_in_use_exception::de_table_in_use_exception_json_err(_response_body, output)
  103     88   
                    .map_err(crate::operation::create_backup::CreateBackupError::unhandled)?;
  104     89   
                let output = output.meta(generic);
  105     90   
                output.build()
  106     91   
            };
  107         -
            if tmp.message.is_none() {
  108         -
                tmp.message = _error_message;
  109         -
            }
  110     92   
            tmp
  111     93   
        }),
  112     94   
        "TableNotFoundException" => crate::operation::create_backup::CreateBackupError::TableNotFoundError({
  113     95   
            #[allow(unused_mut)]
  114     96   
            let mut tmp = {
  115     97   
                #[allow(unused_mut)]
  116     98   
                let mut output = crate::types::error::builders::TableNotFoundErrorBuilder::default();
  117     99   
                output = crate::protocol_serde::shape_table_not_found_exception::de_table_not_found_exception_json_err(_response_body, output)
  118    100   
                    .map_err(crate::operation::create_backup::CreateBackupError::unhandled)?;
  119    101   
                let output = output.meta(generic);
  120    102   
                output.build()
  121    103   
            };
  122         -
            if tmp.message.is_none() {
  123         -
                tmp.message = _error_message;
  124         -
            }
  125    104   
            tmp
  126    105   
        }),
  127    106   
        _ => crate::operation::create_backup::CreateBackupError::generic(generic),
  128    107   
    })
  129    108   
}
  130    109   
  131    110   
#[allow(clippy::unnecessary_wraps)]
  132    111   
pub fn de_create_backup_http_response(
  133    112   
    _response_status: u16,
  134    113   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_create_global_table.rs

@@ -3,3 +125,110 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::GlobalTableAlreadyExistsErrorBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_global_table_already_exists_exception::de_global_table_already_exists_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;
   30     30   
                let output = output.meta(generic);
   31     31   
                output.build()
   32     32   
            };
   33         -
            if tmp.message.is_none() {
   34         -
                tmp.message = _error_message;
   35         -
            }
   36     33   
            tmp
   37     34   
        }),
   38     35   
        "InternalServerError" => crate::operation::create_global_table::CreateGlobalTableError::InternalServerError({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;
   45     42   
                let output = output.meta(generic);
   46     43   
                output.build()
   47     44   
            };
   48         -
            if tmp.message.is_none() {
   49         -
                tmp.message = _error_message;
   50         -
            }
   51     45   
            tmp
   52     46   
        }),
   53     47   
        "InvalidEndpointException" => crate::operation::create_global_table::CreateGlobalTableError::InvalidEndpointError({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;
   60     54   
                let output = output.meta(generic);
   61     55   
                output.build()
   62     56   
            };
   63         -
            if tmp.message.is_none() {
   64         -
                tmp.message = _error_message;
   65         -
            }
   66     57   
            tmp
   67     58   
        }),
   68     59   
        "LimitExceededException" => crate::operation::create_global_table::CreateGlobalTableError::LimitExceededError({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::LimitExceededErrorBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;
   75     66   
                let output = output.meta(generic);
   76     67   
                output.build()
   77     68   
            };
   78         -
            if tmp.message.is_none() {
   79         -
                tmp.message = _error_message;
   80         -
            }
   81     69   
            tmp
   82     70   
        }),
   83     71   
        "TableNotFoundException" => crate::operation::create_global_table::CreateGlobalTableError::TableNotFoundError({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::TableNotFoundErrorBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_table_not_found_exception::de_table_not_found_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        _ => crate::operation::create_global_table::CreateGlobalTableError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_create_global_table_http_response(
  104     89   
    _response_status: u16,
  105     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_create_table.rs

@@ -1,1 +106,94 @@
   19     19   
        "InternalServerError" => crate::operation::create_table::CreateTableError::InternalServerError({
   20     20   
            #[allow(unused_mut)]
   21     21   
            let mut tmp = {
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   25     25   
                    .map_err(crate::operation::create_table::CreateTableError::unhandled)?;
   26     26   
                let output = output.meta(generic);
   27     27   
                output.build()
   28     28   
            };
   29         -
            if tmp.message.is_none() {
   30         -
                tmp.message = _error_message;
   31         -
            }
   32     29   
            tmp
   33     30   
        }),
   34     31   
        "InvalidEndpointException" => crate::operation::create_table::CreateTableError::InvalidEndpointError({
   35     32   
            #[allow(unused_mut)]
   36     33   
            let mut tmp = {
   37     34   
                #[allow(unused_mut)]
   38     35   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   39     36   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   40     37   
                    .map_err(crate::operation::create_table::CreateTableError::unhandled)?;
   41     38   
                let output = output.meta(generic);
   42     39   
                output.build()
   43     40   
            };
   44         -
            if tmp.message.is_none() {
   45         -
                tmp.message = _error_message;
   46         -
            }
   47     41   
            tmp
   48     42   
        }),
   49     43   
        "LimitExceededException" => crate::operation::create_table::CreateTableError::LimitExceededError({
   50     44   
            #[allow(unused_mut)]
   51     45   
            let mut tmp = {
   52     46   
                #[allow(unused_mut)]
   53     47   
                let mut output = crate::types::error::builders::LimitExceededErrorBuilder::default();
   54     48   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   55     49   
                    .map_err(crate::operation::create_table::CreateTableError::unhandled)?;
   56     50   
                let output = output.meta(generic);
   57     51   
                output.build()
   58     52   
            };
   59         -
            if tmp.message.is_none() {
   60         -
                tmp.message = _error_message;
   61         -
            }
   62     53   
            tmp
   63     54   
        }),
   64     55   
        "ResourceInUseException" => crate::operation::create_table::CreateTableError::ResourceInUseError({
   65     56   
            #[allow(unused_mut)]
   66     57   
            let mut tmp = {
   67     58   
                #[allow(unused_mut)]
   68     59   
                let mut output = crate::types::error::builders::ResourceInUseErrorBuilder::default();
   69     60   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   70     61   
                    .map_err(crate::operation::create_table::CreateTableError::unhandled)?;
   71     62   
                let output = output.meta(generic);
   72     63   
                output.build()
   73     64   
            };
   74         -
            if tmp.message.is_none() {
   75         -
                tmp.message = _error_message;
   76         -
            }
   77     65   
            tmp
   78     66   
        }),
   79     67   
        _ => crate::operation::create_table::CreateTableError::generic(generic),
   80     68   
    })
   81     69   
}
   82     70   
   83     71   
#[allow(clippy::unnecessary_wraps)]
   84     72   
pub fn de_create_table_http_response(
   85     73   
    _response_status: u16,
   86     74   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_delete_backup.rs

@@ -1,1 +121,106 @@
   19     19   
        "BackupInUseException" => crate::operation::delete_backup::DeleteBackupError::BackupInUseError({
   20     20   
            #[allow(unused_mut)]
   21     21   
            let mut tmp = {
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::BackupInUseErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_backup_in_use_exception::de_backup_in_use_exception_json_err(_response_body, output)
   25     25   
                    .map_err(crate::operation::delete_backup::DeleteBackupError::unhandled)?;
   26     26   
                let output = output.meta(generic);
   27     27   
                output.build()
   28     28   
            };
   29         -
            if tmp.message.is_none() {
   30         -
                tmp.message = _error_message;
   31         -
            }
   32     29   
            tmp
   33     30   
        }),
   34     31   
        "BackupNotFoundException" => crate::operation::delete_backup::DeleteBackupError::BackupNotFoundError({
   35     32   
            #[allow(unused_mut)]
   36     33   
            let mut tmp = {
   37     34   
                #[allow(unused_mut)]
   38     35   
                let mut output = crate::types::error::builders::BackupNotFoundErrorBuilder::default();
   39     36   
                output = crate::protocol_serde::shape_backup_not_found_exception::de_backup_not_found_exception_json_err(_response_body, output)
   40     37   
                    .map_err(crate::operation::delete_backup::DeleteBackupError::unhandled)?;
   41     38   
                let output = output.meta(generic);
   42     39   
                output.build()
   43     40   
            };
   44         -
            if tmp.message.is_none() {
   45         -
                tmp.message = _error_message;
   46         -
            }
   47     41   
            tmp
   48     42   
        }),
   49     43   
        "InternalServerError" => crate::operation::delete_backup::DeleteBackupError::InternalServerError({
   50     44   
            #[allow(unused_mut)]
   51     45   
            let mut tmp = {
   52     46   
                #[allow(unused_mut)]
   53     47   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   54     48   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   55     49   
                    .map_err(crate::operation::delete_backup::DeleteBackupError::unhandled)?;
   56     50   
                let output = output.meta(generic);
   57     51   
                output.build()
   58     52   
            };
   59         -
            if tmp.message.is_none() {
   60         -
                tmp.message = _error_message;
   61         -
            }
   62     53   
            tmp
   63     54   
        }),
   64     55   
        "InvalidEndpointException" => crate::operation::delete_backup::DeleteBackupError::InvalidEndpointError({
   65     56   
            #[allow(unused_mut)]
   66     57   
            let mut tmp = {
   67     58   
                #[allow(unused_mut)]
   68     59   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   69     60   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   70     61   
                    .map_err(crate::operation::delete_backup::DeleteBackupError::unhandled)?;
   71     62   
                let output = output.meta(generic);
   72     63   
                output.build()
   73     64   
            };
   74         -
            if tmp.message.is_none() {
   75         -
                tmp.message = _error_message;
   76         -
            }
   77     65   
            tmp
   78     66   
        }),
   79     67   
        "LimitExceededException" => crate::operation::delete_backup::DeleteBackupError::LimitExceededError({
   80     68   
            #[allow(unused_mut)]
   81     69   
            let mut tmp = {
   82     70   
                #[allow(unused_mut)]
   83     71   
                let mut output = crate::types::error::builders::LimitExceededErrorBuilder::default();
   84     72   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   85     73   
                    .map_err(crate::operation::delete_backup::DeleteBackupError::unhandled)?;
   86     74   
                let output = output.meta(generic);
   87     75   
                output.build()
   88     76   
            };
   89         -
            if tmp.message.is_none() {
   90         -
                tmp.message = _error_message;
   91         -
            }
   92     77   
            tmp
   93     78   
        }),
   94     79   
        _ => crate::operation::delete_backup::DeleteBackupError::generic(generic),
   95     80   
    })
   96     81   
}
   97     82   
   98     83   
#[allow(clippy::unnecessary_wraps)]
   99     84   
pub fn de_delete_backup_http_response(
  100     85   
    _response_status: u16,
  101     86   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_delete_item.rs

@@ -2,2 +170,146 @@
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::ConditionalCheckFailedErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_conditional_check_failed_exception::de_conditional_check_failed_exception_json_err(
   25     25   
                    _response_body,
   26     26   
                    output,
   27     27   
                )
   28     28   
                .map_err(crate::operation::delete_item::DeleteItemError::unhandled)?;
   29     29   
                let output = output.meta(generic);
   30     30   
                output.build()
   31     31   
            };
   32         -
            if tmp.message.is_none() {
   33         -
                tmp.message = _error_message;
   34         -
            }
   35     32   
            tmp
   36     33   
        }),
   37     34   
        "InternalServerError" => crate::operation::delete_item::DeleteItemError::InternalServerError({
   38     35   
            #[allow(unused_mut)]
   39     36   
            let mut tmp = {
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   42     39   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   43     40   
                    .map_err(crate::operation::delete_item::DeleteItemError::unhandled)?;
   44     41   
                let output = output.meta(generic);
   45     42   
                output.build()
   46     43   
            };
   47         -
            if tmp.message.is_none() {
   48         -
                tmp.message = _error_message;
   49         -
            }
   50     44   
            tmp
   51     45   
        }),
   52     46   
        "InvalidEndpointException" => crate::operation::delete_item::DeleteItemError::InvalidEndpointError({
   53     47   
            #[allow(unused_mut)]
   54     48   
            let mut tmp = {
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   57     51   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   58     52   
                    .map_err(crate::operation::delete_item::DeleteItemError::unhandled)?;
   59     53   
                let output = output.meta(generic);
   60     54   
                output.build()
   61     55   
            };
   62         -
            if tmp.message.is_none() {
   63         -
                tmp.message = _error_message;
   64         -
            }
   65     56   
            tmp
   66     57   
        }),
   67     58   
        "ItemCollectionSizeLimitExceededException" => crate::operation::delete_item::DeleteItemError::ItemCollectionSizeLimitExceededError({
   68     59   
            #[allow(unused_mut)]
   69     60   
            let mut tmp = {
   70     61   
                #[allow(unused_mut)]
   71     62   
                let mut output = crate::types::error::builders::ItemCollectionSizeLimitExceededErrorBuilder::default();
   72     63   
                output = crate::protocol_serde::shape_item_collection_size_limit_exceeded_exception::de_item_collection_size_limit_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::delete_item::DeleteItemError::unhandled)?;
   73     64   
                let output = output.meta(generic);
   74     65   
                output.build()
   75     66   
            };
   76         -
            if tmp.message.is_none() {
   77         -
                tmp.message = _error_message;
   78         -
            }
   79     67   
            tmp
   80     68   
        }),
   81     69   
        "ProvisionedThroughputExceededException" => {
   82     70   
            crate::operation::delete_item::DeleteItemError::ProvisionedThroughputExceededError({
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut tmp = {
   85     73   
                    #[allow(unused_mut)]
   86     74   
                    let mut output = crate::types::error::builders::ProvisionedThroughputExceededErrorBuilder::default();
   87     75   
                    output = crate::protocol_serde::shape_provisioned_throughput_exceeded_exception::de_provisioned_throughput_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::delete_item::DeleteItemError::unhandled)?;
   88     76   
                    let output = output.meta(generic);
   89     77   
                    output.build()
   90     78   
                };
   91         -
                if tmp.message.is_none() {
   92         -
                    tmp.message = _error_message;
   93         -
                }
   94     79   
                tmp
   95     80   
            })
   96     81   
        }
   97     82   
        "RequestLimitExceeded" => crate::operation::delete_item::DeleteItemError::RequestLimitExceeded({
   98     83   
            #[allow(unused_mut)]
   99     84   
            let mut tmp = {
  100     85   
                #[allow(unused_mut)]
  101     86   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
  102     87   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
  103     88   
                    .map_err(crate::operation::delete_item::DeleteItemError::unhandled)?;
  104     89   
                let output = output.meta(generic);
  105     90   
                output.build()
  106     91   
            };
  107         -
            if tmp.message.is_none() {
  108         -
                tmp.message = _error_message;
  109         -
            }
  110     92   
            tmp
  111     93   
        }),
  112     94   
        "ResourceNotFoundException" => crate::operation::delete_item::DeleteItemError::ResourceNotFoundError({
  113     95   
            #[allow(unused_mut)]
  114     96   
            let mut tmp = {
  115     97   
                #[allow(unused_mut)]
  116     98   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
  117     99   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  118    100   
                    .map_err(crate::operation::delete_item::DeleteItemError::unhandled)?;
  119    101   
                let output = output.meta(generic);
  120    102   
                output.build()
  121    103   
            };
  122         -
            if tmp.message.is_none() {
  123         -
                tmp.message = _error_message;
  124         -
            }
  125    104   
            tmp
  126    105   
        }),
  127    106   
        "TransactionConflictException" => crate::operation::delete_item::DeleteItemError::TransactionConflictError({
  128    107   
            #[allow(unused_mut)]
  129    108   
            let mut tmp = {
  130    109   
                #[allow(unused_mut)]
  131    110   
                let mut output = crate::types::error::builders::TransactionConflictErrorBuilder::default();
  132    111   
                output =
  133    112   
                    crate::protocol_serde::shape_transaction_conflict_exception::de_transaction_conflict_exception_json_err(_response_body, output)
  134    113   
                        .map_err(crate::operation::delete_item::DeleteItemError::unhandled)?;
  135    114   
                let output = output.meta(generic);
  136    115   
                output.build()
  137    116   
            };
  138         -
            if tmp.message.is_none() {
  139         -
                tmp.message = _error_message;
  140         -
            }
  141    117   
            tmp
  142    118   
        }),
  143    119   
        _ => crate::operation::delete_item::DeleteItemError::generic(generic),
  144    120   
    })
  145    121   
}
  146    122   
  147    123   
#[allow(clippy::unnecessary_wraps)]
  148    124   
pub fn de_delete_item_http_response(
  149    125   
    _response_status: u16,
  150    126   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_delete_table.rs

@@ -1,1 +121,106 @@
   19     19   
        "InternalServerError" => crate::operation::delete_table::DeleteTableError::InternalServerError({
   20     20   
            #[allow(unused_mut)]
   21     21   
            let mut tmp = {
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   25     25   
                    .map_err(crate::operation::delete_table::DeleteTableError::unhandled)?;
   26     26   
                let output = output.meta(generic);
   27     27   
                output.build()
   28     28   
            };
   29         -
            if tmp.message.is_none() {
   30         -
                tmp.message = _error_message;
   31         -
            }
   32     29   
            tmp
   33     30   
        }),
   34     31   
        "InvalidEndpointException" => crate::operation::delete_table::DeleteTableError::InvalidEndpointError({
   35     32   
            #[allow(unused_mut)]
   36     33   
            let mut tmp = {
   37     34   
                #[allow(unused_mut)]
   38     35   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   39     36   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   40     37   
                    .map_err(crate::operation::delete_table::DeleteTableError::unhandled)?;
   41     38   
                let output = output.meta(generic);
   42     39   
                output.build()
   43     40   
            };
   44         -
            if tmp.message.is_none() {
   45         -
                tmp.message = _error_message;
   46         -
            }
   47     41   
            tmp
   48     42   
        }),
   49     43   
        "LimitExceededException" => crate::operation::delete_table::DeleteTableError::LimitExceededError({
   50     44   
            #[allow(unused_mut)]
   51     45   
            let mut tmp = {
   52     46   
                #[allow(unused_mut)]
   53     47   
                let mut output = crate::types::error::builders::LimitExceededErrorBuilder::default();
   54     48   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   55     49   
                    .map_err(crate::operation::delete_table::DeleteTableError::unhandled)?;
   56     50   
                let output = output.meta(generic);
   57     51   
                output.build()
   58     52   
            };
   59         -
            if tmp.message.is_none() {
   60         -
                tmp.message = _error_message;
   61         -
            }
   62     53   
            tmp
   63     54   
        }),
   64     55   
        "ResourceInUseException" => crate::operation::delete_table::DeleteTableError::ResourceInUseError({
   65     56   
            #[allow(unused_mut)]
   66     57   
            let mut tmp = {
   67     58   
                #[allow(unused_mut)]
   68     59   
                let mut output = crate::types::error::builders::ResourceInUseErrorBuilder::default();
   69     60   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   70     61   
                    .map_err(crate::operation::delete_table::DeleteTableError::unhandled)?;
   71     62   
                let output = output.meta(generic);
   72     63   
                output.build()
   73     64   
            };
   74         -
            if tmp.message.is_none() {
   75         -
                tmp.message = _error_message;
   76         -
            }
   77     65   
            tmp
   78     66   
        }),
   79     67   
        "ResourceNotFoundException" => crate::operation::delete_table::DeleteTableError::ResourceNotFoundError({
   80     68   
            #[allow(unused_mut)]
   81     69   
            let mut tmp = {
   82     70   
                #[allow(unused_mut)]
   83     71   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   84     72   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   85     73   
                    .map_err(crate::operation::delete_table::DeleteTableError::unhandled)?;
   86     74   
                let output = output.meta(generic);
   87     75   
                output.build()
   88     76   
            };
   89         -
            if tmp.message.is_none() {
   90         -
                tmp.message = _error_message;
   91         -
            }
   92     77   
            tmp
   93     78   
        }),
   94     79   
        _ => crate::operation::delete_table::DeleteTableError::generic(generic),
   95     80   
    })
   96     81   
}
   97     82   
   98     83   
#[allow(clippy::unnecessary_wraps)]
   99     84   
pub fn de_delete_table_http_response(
  100     85   
    _response_status: u16,
  101     86   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_describe_backup.rs

@@ -1,1 +91,82 @@
   19     19   
        "BackupNotFoundException" => crate::operation::describe_backup::DescribeBackupError::BackupNotFoundError({
   20     20   
            #[allow(unused_mut)]
   21     21   
            let mut tmp = {
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::BackupNotFoundErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_backup_not_found_exception::de_backup_not_found_exception_json_err(_response_body, output)
   25     25   
                    .map_err(crate::operation::describe_backup::DescribeBackupError::unhandled)?;
   26     26   
                let output = output.meta(generic);
   27     27   
                output.build()
   28     28   
            };
   29         -
            if tmp.message.is_none() {
   30         -
                tmp.message = _error_message;
   31         -
            }
   32     29   
            tmp
   33     30   
        }),
   34     31   
        "InternalServerError" => crate::operation::describe_backup::DescribeBackupError::InternalServerError({
   35     32   
            #[allow(unused_mut)]
   36     33   
            let mut tmp = {
   37     34   
                #[allow(unused_mut)]
   38     35   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   39     36   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   40     37   
                    .map_err(crate::operation::describe_backup::DescribeBackupError::unhandled)?;
   41     38   
                let output = output.meta(generic);
   42     39   
                output.build()
   43     40   
            };
   44         -
            if tmp.message.is_none() {
   45         -
                tmp.message = _error_message;
   46         -
            }
   47     41   
            tmp
   48     42   
        }),
   49     43   
        "InvalidEndpointException" => crate::operation::describe_backup::DescribeBackupError::InvalidEndpointError({
   50     44   
            #[allow(unused_mut)]
   51     45   
            let mut tmp = {
   52     46   
                #[allow(unused_mut)]
   53     47   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   54     48   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   55     49   
                    .map_err(crate::operation::describe_backup::DescribeBackupError::unhandled)?;
   56     50   
                let output = output.meta(generic);
   57     51   
                output.build()
   58     52   
            };
   59         -
            if tmp.message.is_none() {
   60         -
                tmp.message = _error_message;
   61         -
            }
   62     53   
            tmp
   63     54   
        }),
   64     55   
        _ => crate::operation::describe_backup::DescribeBackupError::generic(generic),
   65     56   
    })
   66     57   
}
   67     58   
   68     59   
#[allow(clippy::unnecessary_wraps)]
   69     60   
pub fn de_describe_backup_http_response(
   70     61   
    _response_status: u16,
   71     62   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_describe_continuous_backups.rs

@@ -6,6 +98,89 @@
   26     26   
        "InternalServerError" => crate::operation::describe_continuous_backups::DescribeContinuousBackupsError::InternalServerError({
   27     27   
            #[allow(unused_mut)]
   28     28   
            let mut tmp = {
   29     29   
                #[allow(unused_mut)]
   30     30   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   31     31   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   32     32   
                    .map_err(crate::operation::describe_continuous_backups::DescribeContinuousBackupsError::unhandled)?;
   33     33   
                let output = output.meta(generic);
   34     34   
                output.build()
   35     35   
            };
   36         -
            if tmp.message.is_none() {
   37         -
                tmp.message = _error_message;
   38         -
            }
   39     36   
            tmp
   40     37   
        }),
   41     38   
        "InvalidEndpointException" => crate::operation::describe_continuous_backups::DescribeContinuousBackupsError::InvalidEndpointError({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::describe_continuous_backups::DescribeContinuousBackupsError::unhandled)?;
   48     45   
                let output = output.meta(generic);
   49     46   
                output.build()
   50     47   
            };
   51         -
            if tmp.message.is_none() {
   52         -
                tmp.message = _error_message;
   53         -
            }
   54     48   
            tmp
   55     49   
        }),
   56     50   
        "TableNotFoundException" => crate::operation::describe_continuous_backups::DescribeContinuousBackupsError::TableNotFoundError({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::TableNotFoundErrorBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_table_not_found_exception::de_table_not_found_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::describe_continuous_backups::DescribeContinuousBackupsError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        _ => crate::operation::describe_continuous_backups::DescribeContinuousBackupsError::generic(generic),
   72     63   
    })
   73     64   
}
   74     65   
   75     66   
#[allow(clippy::unnecessary_wraps)]
   76     67   
pub fn de_describe_continuous_backups_http_response(
   77     68   
    _response_status: u16,
   78     69   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_describe_contributor_insights.rs

@@ -2,2 +79,73 @@
   22     22   
        "InternalServerError" => crate::operation::describe_contributor_insights::DescribeContributorInsightsError::InternalServerError({
   23     23   
            #[allow(unused_mut)]
   24     24   
            let mut tmp = {
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   27     27   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   28     28   
                    .map_err(crate::operation::describe_contributor_insights::DescribeContributorInsightsError::unhandled)?;
   29     29   
                let output = output.meta(generic);
   30     30   
                output.build()
   31     31   
            };
   32         -
            if tmp.message.is_none() {
   33         -
                tmp.message = _error_message;
   34         -
            }
   35     32   
            tmp
   36     33   
        }),
   37     34   
        "ResourceNotFoundException" => crate::operation::describe_contributor_insights::DescribeContributorInsightsError::ResourceNotFoundError({
   38     35   
            #[allow(unused_mut)]
   39     36   
            let mut tmp = {
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   42     39   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   43     40   
                    .map_err(crate::operation::describe_contributor_insights::DescribeContributorInsightsError::unhandled)?;
   44     41   
                let output = output.meta(generic);
   45     42   
                output.build()
   46     43   
            };
   47         -
            if tmp.message.is_none() {
   48         -
                tmp.message = _error_message;
   49         -
            }
   50     44   
            tmp
   51     45   
        }),
   52     46   
        _ => crate::operation::describe_contributor_insights::DescribeContributorInsightsError::generic(generic),
   53     47   
    })
   54     48   
}
   55     49   
   56     50   
#[allow(clippy::unnecessary_wraps)]
   57     51   
pub fn de_describe_contributor_insights_http_response(
   58     52   
    _response_status: u16,
   59     53   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_describe_export.rs

@@ -1,1 +91,82 @@
   19     19   
        "ExportNotFoundException" => crate::operation::describe_export::DescribeExportError::ExportNotFoundError({
   20     20   
            #[allow(unused_mut)]
   21     21   
            let mut tmp = {
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::ExportNotFoundErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_export_not_found_exception::de_export_not_found_exception_json_err(_response_body, output)
   25     25   
                    .map_err(crate::operation::describe_export::DescribeExportError::unhandled)?;
   26     26   
                let output = output.meta(generic);
   27     27   
                output.build()
   28     28   
            };
   29         -
            if tmp.message.is_none() {
   30         -
                tmp.message = _error_message;
   31         -
            }
   32     29   
            tmp
   33     30   
        }),
   34     31   
        "InternalServerError" => crate::operation::describe_export::DescribeExportError::InternalServerError({
   35     32   
            #[allow(unused_mut)]
   36     33   
            let mut tmp = {
   37     34   
                #[allow(unused_mut)]
   38     35   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   39     36   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   40     37   
                    .map_err(crate::operation::describe_export::DescribeExportError::unhandled)?;
   41     38   
                let output = output.meta(generic);
   42     39   
                output.build()
   43     40   
            };
   44         -
            if tmp.message.is_none() {
   45         -
                tmp.message = _error_message;
   46         -
            }
   47     41   
            tmp
   48     42   
        }),
   49     43   
        "LimitExceededException" => crate::operation::describe_export::DescribeExportError::LimitExceededError({
   50     44   
            #[allow(unused_mut)]
   51     45   
            let mut tmp = {
   52     46   
                #[allow(unused_mut)]
   53     47   
                let mut output = crate::types::error::builders::LimitExceededErrorBuilder::default();
   54     48   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   55     49   
                    .map_err(crate::operation::describe_export::DescribeExportError::unhandled)?;
   56     50   
                let output = output.meta(generic);
   57     51   
                output.build()
   58     52   
            };
   59         -
            if tmp.message.is_none() {
   60         -
                tmp.message = _error_message;
   61         -
            }
   62     53   
            tmp
   63     54   
        }),
   64     55   
        _ => crate::operation::describe_export::DescribeExportError::generic(generic),
   65     56   
    })
   66     57   
}
   67     58   
   68     59   
#[allow(clippy::unnecessary_wraps)]
   69     60   
pub fn de_describe_export_http_response(
   70     61   
    _response_status: u16,
   71     62   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,