AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05

Files changed:

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_delete_backup.rs

@@ -1,1 +122,107 @@
   20     20   
        "BackupInUseException" => crate::operation::delete_backup::DeleteBackupError::BackupInUseException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::BackupInUseExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_backup_in_use_exception::de_backup_in_use_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::delete_backup::DeleteBackupError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "BackupNotFoundException" => crate::operation::delete_backup::DeleteBackupError::BackupNotFoundException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::BackupNotFoundExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_backup_not_found_exception::de_backup_not_found_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::delete_backup::DeleteBackupError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "InternalServerError" => crate::operation::delete_backup::DeleteBackupError::InternalServerError({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::delete_backup::DeleteBackupError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "InvalidEndpointException" => crate::operation::delete_backup::DeleteBackupError::InvalidEndpointException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::delete_backup::DeleteBackupError::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   
        "LimitExceededException" => crate::operation::delete_backup::DeleteBackupError::LimitExceededException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::delete_backup::DeleteBackupError::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::delete_backup::DeleteBackupError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_delete_backup_http_response(
  101     86   
    _response_status: u16,
  102     87   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_delete_item.rs

@@ -3,3 +171,147 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ConditionalCheckFailedExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_conditional_check_failed_exception::de_conditional_check_failed_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::delete_item::DeleteItemError::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::delete_item::DeleteItemError::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::delete_item::DeleteItemError::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::delete_item::DeleteItemError::InvalidEndpointException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::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::delete_item::DeleteItemError::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   
        "ItemCollectionSizeLimitExceededException" => crate::operation::delete_item::DeleteItemError::ItemCollectionSizeLimitExceededException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::ItemCollectionSizeLimitExceededExceptionBuilder::default();
   73     64   
                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)?;
   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   
        "ProvisionedThroughputExceededException" => {
   83     71   
            crate::operation::delete_item::DeleteItemError::ProvisionedThroughputExceededException({
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut tmp = {
   86     74   
                    #[allow(unused_mut)]
   87     75   
                    let mut output = crate::types::error::builders::ProvisionedThroughputExceededExceptionBuilder::default();
   88     76   
                    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)?;
   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   
        }
   98     83   
        "RequestLimitExceeded" => crate::operation::delete_item::DeleteItemError::RequestLimitExceeded({
   99     84   
            #[allow(unused_mut)]
  100     85   
            let mut tmp = {
  101     86   
                #[allow(unused_mut)]
  102     87   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
  103     88   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
  104     89   
                    .map_err(crate::operation::delete_item::DeleteItemError::unhandled)?;
  105     90   
                let output = output.meta(generic);
  106     91   
                output.build()
  107     92   
            };
  108         -
            if tmp.message.is_none() {
  109         -
                tmp.message = _error_message;
  110         -
            }
  111     93   
            tmp
  112     94   
        }),
  113     95   
        "ResourceNotFoundException" => crate::operation::delete_item::DeleteItemError::ResourceNotFoundException({
  114     96   
            #[allow(unused_mut)]
  115     97   
            let mut tmp = {
  116     98   
                #[allow(unused_mut)]
  117     99   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
  118    100   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  119    101   
                    .map_err(crate::operation::delete_item::DeleteItemError::unhandled)?;
  120    102   
                let output = output.meta(generic);
  121    103   
                output.build()
  122    104   
            };
  123         -
            if tmp.message.is_none() {
  124         -
                tmp.message = _error_message;
  125         -
            }
  126    105   
            tmp
  127    106   
        }),
  128    107   
        "TransactionConflictException" => crate::operation::delete_item::DeleteItemError::TransactionConflictException({
  129    108   
            #[allow(unused_mut)]
  130    109   
            let mut tmp = {
  131    110   
                #[allow(unused_mut)]
  132    111   
                let mut output = crate::types::error::builders::TransactionConflictExceptionBuilder::default();
  133    112   
                output =
  134    113   
                    crate::protocol_serde::shape_transaction_conflict_exception::de_transaction_conflict_exception_json_err(_response_body, output)
  135    114   
                        .map_err(crate::operation::delete_item::DeleteItemError::unhandled)?;
  136    115   
                let output = output.meta(generic);
  137    116   
                output.build()
  138    117   
            };
  139         -
            if tmp.message.is_none() {
  140         -
                tmp.message = _error_message;
  141         -
            }
  142    118   
            tmp
  143    119   
        }),
  144    120   
        _ => crate::operation::delete_item::DeleteItemError::generic(generic),
  145    121   
    })
  146    122   
}
  147    123   
  148    124   
#[allow(clippy::unnecessary_wraps)]
  149    125   
pub fn de_delete_item_http_response(
  150    126   
    _response_status: u16,
  151    127   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_delete_resource_policy.rs

@@ -3,3 +140,122 @@
   23     23   
        "InternalServerError" => crate::operation::delete_resource_policy::DeleteResourcePolicyError::InternalServerError({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::delete_resource_policy::DeleteResourcePolicyError::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   
        "InvalidEndpointException" => crate::operation::delete_resource_policy::DeleteResourcePolicyError::InvalidEndpointException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::delete_resource_policy::DeleteResourcePolicyError::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   
        "LimitExceededException" => crate::operation::delete_resource_policy::DeleteResourcePolicyError::LimitExceededException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::delete_resource_policy::DeleteResourcePolicyError::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   
        "PolicyNotFoundException" => crate::operation::delete_resource_policy::DeleteResourcePolicyError::PolicyNotFoundException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::PolicyNotFoundExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_policy_not_found_exception::de_policy_not_found_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::delete_resource_policy::DeleteResourcePolicyError::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   
        "ResourceInUseException" => crate::operation::delete_resource_policy::DeleteResourcePolicyError::ResourceInUseException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::delete_resource_policy::DeleteResourcePolicyError::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   
        "ResourceNotFoundException" => crate::operation::delete_resource_policy::DeleteResourcePolicyError::ResourceNotFoundException({
   99     84   
            #[allow(unused_mut)]
  100     85   
            let mut tmp = {
  101     86   
                #[allow(unused_mut)]
  102     87   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
  103     88   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  104     89   
                    .map_err(crate::operation::delete_resource_policy::DeleteResourcePolicyError::unhandled)?;
  105     90   
                let output = output.meta(generic);
  106     91   
                output.build()
  107     92   
            };
  108         -
            if tmp.message.is_none() {
  109         -
                tmp.message = _error_message;
  110         -
            }
  111     93   
            tmp
  112     94   
        }),
  113     95   
        _ => crate::operation::delete_resource_policy::DeleteResourcePolicyError::generic(generic),
  114     96   
    })
  115     97   
}
  116     98   
  117     99   
#[allow(clippy::unnecessary_wraps)]
  118    100   
pub fn de_delete_resource_policy_http_response(
  119    101   
    _response_status: u16,
  120    102   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_delete_table.rs

@@ -1,1 +122,107 @@
   20     20   
        "InternalServerError" => crate::operation::delete_table::DeleteTableError::InternalServerError({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::delete_table::DeleteTableError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "InvalidEndpointException" => crate::operation::delete_table::DeleteTableError::InvalidEndpointException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::delete_table::DeleteTableError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "LimitExceededException" => crate::operation::delete_table::DeleteTableError::LimitExceededException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::delete_table::DeleteTableError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "ResourceInUseException" => crate::operation::delete_table::DeleteTableError::ResourceInUseException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::delete_table::DeleteTableError::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::delete_table::DeleteTableError::ResourceNotFoundException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::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::delete_table::DeleteTableError::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::delete_table::DeleteTableError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_delete_table_http_response(
  101     86   
    _response_status: u16,
  102     87   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_describe_backup.rs

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_describe_continuous_backups.rs

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_describe_contributor_insights.rs

@@ -3,3 +82,76 @@
   23     23   
        "InternalServerError" => crate::operation::describe_contributor_insights::DescribeContributorInsightsError::InternalServerError({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::describe_contributor_insights::DescribeContributorInsightsError::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   
        "ResourceNotFoundException" => {
   39     36   
            crate::operation::describe_contributor_insights::DescribeContributorInsightsError::ResourceNotFoundException({
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut tmp = {
   42     39   
                    #[allow(unused_mut)]
   43     40   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   44     41   
                    output =
   45     42   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   46     43   
                            .map_err(crate::operation::describe_contributor_insights::DescribeContributorInsightsError::unhandled)?;
   47     44   
                    let output = output.meta(generic);
   48     45   
                    output.build()
   49     46   
                };
   50         -
                if tmp.message.is_none() {
   51         -
                    tmp.message = _error_message;
   52         -
                }
   53     47   
                tmp
   54     48   
            })
   55     49   
        }
   56     50   
        _ => crate::operation::describe_contributor_insights::DescribeContributorInsightsError::generic(generic),
   57     51   
    })
   58     52   
}
   59     53   
   60     54   
#[allow(clippy::unnecessary_wraps)]
   61     55   
pub fn de_describe_contributor_insights_http_response(
   62     56   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_describe_export.rs

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_describe_global_table.rs

@@ -6,6 +98,89 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::GlobalTableNotFoundExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_global_table_not_found_exception::de_global_table_not_found_exception_json_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::describe_global_table::DescribeGlobalTableError::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   
        "InternalServerError" => crate::operation::describe_global_table::DescribeGlobalTableError::InternalServerError({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::describe_global_table::DescribeGlobalTableError::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   
        "InvalidEndpointException" => crate::operation::describe_global_table::DescribeGlobalTableError::InvalidEndpointException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::describe_global_table::DescribeGlobalTableError::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_global_table::DescribeGlobalTableError::generic(generic),
   72     63   
    })
   73     64   
}
   74     65   
   75     66   
#[allow(clippy::unnecessary_wraps)]
   76     67   
pub fn de_describe_global_table_http_response(
   77     68   
    _response_status: u16,
   78     69   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_describe_global_table_settings.rs

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_describe_import.rs

@@ -1,1 +62,59 @@
   20     20   
        "ImportNotFoundException" => crate::operation::describe_import::DescribeImportError::ImportNotFoundException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ImportNotFoundExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_import_not_found_exception::de_import_not_found_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::describe_import::DescribeImportError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        _ => crate::operation::describe_import::DescribeImportError::generic(generic),
   36     33   
    })
   37     34   
}
   38     35   
   39     36   
#[allow(clippy::unnecessary_wraps)]
   40     37   
pub fn de_describe_import_http_response(
   41     38   
    _response_status: u16,
   42     39   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_describe_kinesis_streaming_destination.rs

@@ -4,4 +101,92 @@
   24     24   
            crate::operation::describe_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::InternalServerError({
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   30     30   
                        .map_err(crate::operation::describe_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::unhandled)?;
   31     31   
                    let output = output.meta(generic);
   32     32   
                    output.build()
   33     33   
                };
   34         -
                if tmp.message.is_none() {
   35         -
                    tmp.message = _error_message;
   36         -
                }
   37     34   
                tmp
   38     35   
            })
   39     36   
        }
   40     37   
        "InvalidEndpointException" => {
   41     38   
            crate::operation::describe_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::InvalidEndpointException({
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut tmp = {
   44     41   
                    #[allow(unused_mut)]
   45     42   
                    let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::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_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::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   
        }
   57     51   
        "ResourceNotFoundException" => {
   58     52   
            crate::operation::describe_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::ResourceNotFoundException({
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut tmp = {
   61     55   
                    #[allow(unused_mut)]
   62     56   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   63     57   
                    output =
   64     58   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   65     59   
                            .map_err(crate::operation::describe_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::unhandled)?;
   66     60   
                    let output = output.meta(generic);
   67     61   
                    output.build()
   68     62   
                };
   69         -
                if tmp.message.is_none() {
   70         -
                    tmp.message = _error_message;
   71         -
                }
   72     63   
                tmp
   73     64   
            })
   74     65   
        }
   75     66   
        _ => crate::operation::describe_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::generic(generic),
   76     67   
    })
   77     68   
}
   78     69   
   79     70   
#[allow(clippy::unnecessary_wraps)]
   80     71   
pub fn de_describe_kinesis_streaming_destination_http_response(
   81     72   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_describe_limits.rs

@@ -1,1 +77,71 @@
   20     20   
        "InternalServerError" => crate::operation::describe_limits::DescribeLimitsError::InternalServerError({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::describe_limits::DescribeLimitsError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "InvalidEndpointException" => crate::operation::describe_limits::DescribeLimitsError::InvalidEndpointException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::describe_limits::DescribeLimitsError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        _ => crate::operation::describe_limits::DescribeLimitsError::generic(generic),
   51     45   
    })
   52     46   
}
   53     47   
   54     48   
#[allow(clippy::unnecessary_wraps)]
   55     49   
pub fn de_describe_limits_http_response(
   56     50   
    _response_status: u16,
   57     51   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_describe_table.rs

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_describe_table_replica_auto_scaling.rs

@@ -3,3 +82,76 @@
   23     23   
        "InternalServerError" => crate::operation::describe_table_replica_auto_scaling::DescribeTableReplicaAutoScalingError::InternalServerError({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::describe_table_replica_auto_scaling::DescribeTableReplicaAutoScalingError::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   
        "ResourceNotFoundException" => {
   39     36   
            crate::operation::describe_table_replica_auto_scaling::DescribeTableReplicaAutoScalingError::ResourceNotFoundException({
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut tmp = {
   42     39   
                    #[allow(unused_mut)]
   43     40   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   44     41   
                    output =
   45     42   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   46     43   
                            .map_err(crate::operation::describe_table_replica_auto_scaling::DescribeTableReplicaAutoScalingError::unhandled)?;
   47     44   
                    let output = output.meta(generic);
   48     45   
                    output.build()
   49     46   
                };
   50         -
                if tmp.message.is_none() {
   51         -
                    tmp.message = _error_message;
   52         -
                }
   53     47   
                tmp
   54     48   
            })
   55     49   
        }
   56     50   
        _ => crate::operation::describe_table_replica_auto_scaling::DescribeTableReplicaAutoScalingError::generic(generic),
   57     51   
    })
   58     52   
}
   59     53   
   60     54   
#[allow(clippy::unnecessary_wraps)]
   61     55   
pub fn de_describe_table_replica_auto_scaling_http_response(
   62     56   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_describe_time_to_live.rs

@@ -3,3 +95,86 @@
   23     23   
        "InternalServerError" => crate::operation::describe_time_to_live::DescribeTimeToLiveError::InternalServerError({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::describe_time_to_live::DescribeTimeToLiveError::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   
        "InvalidEndpointException" => crate::operation::describe_time_to_live::DescribeTimeToLiveError::InvalidEndpointException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::describe_time_to_live::DescribeTimeToLiveError::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   
        "ResourceNotFoundException" => crate::operation::describe_time_to_live::DescribeTimeToLiveError::ResourceNotFoundException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::describe_time_to_live::DescribeTimeToLiveError::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   
        _ => crate::operation::describe_time_to_live::DescribeTimeToLiveError::generic(generic),
   69     60   
    })
   70     61   
}
   71     62   
   72     63   
#[allow(clippy::unnecessary_wraps)]
   73     64   
pub fn de_describe_time_to_live_http_response(
   74     65   
    _response_status: u16,
   75     66   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,