AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05

Files changed:

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

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

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

@@ -1,1 +123,108 @@
   20     20   
        "InternalServerError" => crate::operation::query::QueryError::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::query::QueryError::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::query::QueryError::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::query::QueryError::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   
        "ProvisionedThroughputExceededException" => {
   51     45   
            crate::operation::query::QueryError::ProvisionedThroughputExceededException({
   52     46   
                #[allow(unused_mut)]
   53     47   
                let mut tmp = {
   54     48   
                    #[allow(unused_mut)]
   55     49   
                    let mut output = crate::types::error::builders::ProvisionedThroughputExceededExceptionBuilder::default();
   56     50   
                    output = crate::protocol_serde::shape_provisioned_throughput_exceeded_exception::de_provisioned_throughput_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::query::QueryError::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   
        }
   66     57   
        "RequestLimitExceeded" => crate::operation::query::QueryError::RequestLimitExceeded({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::query::QueryError::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   
        "ResourceNotFoundException" => crate::operation::query::QueryError::ResourceNotFoundException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   87     75   
                    .map_err(crate::operation::query::QueryError::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   
        _ => crate::operation::query::QueryError::generic(generic),
   97     82   
    })
   98     83   
}
   99     84   
  100     85   
#[allow(clippy::unnecessary_wraps)]
  101     86   
pub fn de_query_http_response(
  102     87   
    _response_status: u16,
  103     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +160,139 @@
   27     27   
        "BackupInUseException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::BackupInUseException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::BackupInUseExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_backup_in_use_exception::de_backup_in_use_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::restore_table_from_backup::RestoreTableFromBackupError::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   
        "BackupNotFoundException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::BackupNotFoundException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::BackupNotFoundExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_backup_not_found_exception::de_backup_not_found_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::restore_table_from_backup::RestoreTableFromBackupError::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   
        "InternalServerError" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::InternalServerError({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::restore_table_from_backup::RestoreTableFromBackupError::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   
        "InvalidEndpointException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::InvalidEndpointException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::restore_table_from_backup::RestoreTableFromBackupError::unhandled)?;
   79     70   
                let output = output.meta(generic);
   80     71   
                output.build()
   81     72   
            };
   82         -
            if tmp.message.is_none() {
   83         -
                tmp.message = _error_message;
   84         -
            }
   85     73   
            tmp
   86     74   
        }),
   87     75   
        "LimitExceededException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::LimitExceededException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::restore_table_from_backup::RestoreTableFromBackupError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        "TableAlreadyExistsException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::TableAlreadyExistsException({
  103     88   
            #[allow(unused_mut)]
  104     89   
            let mut tmp = {
  105     90   
                #[allow(unused_mut)]
  106     91   
                let mut output = crate::types::error::builders::TableAlreadyExistsExceptionBuilder::default();
  107     92   
                output =
  108     93   
                    crate::protocol_serde::shape_table_already_exists_exception::de_table_already_exists_exception_json_err(_response_body, output)
  109     94   
                        .map_err(crate::operation::restore_table_from_backup::RestoreTableFromBackupError::unhandled)?;
  110     95   
                let output = output.meta(generic);
  111     96   
                output.build()
  112     97   
            };
  113         -
            if tmp.message.is_none() {
  114         -
                tmp.message = _error_message;
  115         -
            }
  116     98   
            tmp
  117     99   
        }),
  118    100   
        "TableInUseException" => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::TableInUseException({
  119    101   
            #[allow(unused_mut)]
  120    102   
            let mut tmp = {
  121    103   
                #[allow(unused_mut)]
  122    104   
                let mut output = crate::types::error::builders::TableInUseExceptionBuilder::default();
  123    105   
                output = crate::protocol_serde::shape_table_in_use_exception::de_table_in_use_exception_json_err(_response_body, output)
  124    106   
                    .map_err(crate::operation::restore_table_from_backup::RestoreTableFromBackupError::unhandled)?;
  125    107   
                let output = output.meta(generic);
  126    108   
                output.build()
  127    109   
            };
  128         -
            if tmp.message.is_none() {
  129         -
                tmp.message = _error_message;
  130         -
            }
  131    110   
            tmp
  132    111   
        }),
  133    112   
        _ => crate::operation::restore_table_from_backup::RestoreTableFromBackupError::generic(generic),
  134    113   
    })
  135    114   
}
  136    115   
  137    116   
#[allow(clippy::unnecessary_wraps)]
  138    117   
pub fn de_restore_table_from_backup_http_response(
  139    118   
    _response_status: u16,
  140    119   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +181,157 @@
   23     23   
        "InternalServerError" => crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::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::restore_table_to_point_in_time::RestoreTableToPointInTimeError::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::restore_table_to_point_in_time::RestoreTableToPointInTimeError::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::restore_table_to_point_in_time::RestoreTableToPointInTimeError::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   
        "InvalidRestoreTimeException" => {
   54     48   
            crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::InvalidRestoreTimeException({
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut tmp = {
   57     51   
                    #[allow(unused_mut)]
   58     52   
                    let mut output = crate::types::error::builders::InvalidRestoreTimeExceptionBuilder::default();
   59     53   
                    output = crate::protocol_serde::shape_invalid_restore_time_exception::de_invalid_restore_time_exception_json_err(
   60     54   
                        _response_body,
   61     55   
                        output,
   62     56   
                    )
   63     57   
                    .map_err(crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::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   
        }
   73     64   
        "LimitExceededException" => crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::LimitExceededException({
   74     65   
            #[allow(unused_mut)]
   75     66   
            let mut tmp = {
   76     67   
                #[allow(unused_mut)]
   77     68   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   78     69   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   79     70   
                    .map_err(crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::unhandled)?;
   80     71   
                let output = output.meta(generic);
   81     72   
                output.build()
   82     73   
            };
   83         -
            if tmp.message.is_none() {
   84         -
                tmp.message = _error_message;
   85         -
            }
   86     74   
            tmp
   87     75   
        }),
   88     76   
        "PointInTimeRecoveryUnavailableException" => {
   89     77   
            crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::PointInTimeRecoveryUnavailableException({
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut tmp = {
   92     80   
                    #[allow(unused_mut)]
   93     81   
                    let mut output = crate::types::error::builders::PointInTimeRecoveryUnavailableExceptionBuilder::default();
   94     82   
                    output = crate::protocol_serde::shape_point_in_time_recovery_unavailable_exception::de_point_in_time_recovery_unavailable_exception_json_err(_response_body, output).map_err(crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::unhandled)?;
   95     83   
                    let output = output.meta(generic);
   96     84   
                    output.build()
   97     85   
                };
   98         -
                if tmp.message.is_none() {
   99         -
                    tmp.message = _error_message;
  100         -
                }
  101     86   
                tmp
  102     87   
            })
  103     88   
        }
  104     89   
        "TableAlreadyExistsException" => {
  105     90   
            crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::TableAlreadyExistsException({
  106     91   
                #[allow(unused_mut)]
  107     92   
                let mut tmp = {
  108     93   
                    #[allow(unused_mut)]
  109     94   
                    let mut output = crate::types::error::builders::TableAlreadyExistsExceptionBuilder::default();
  110     95   
                    output = crate::protocol_serde::shape_table_already_exists_exception::de_table_already_exists_exception_json_err(
  111     96   
                        _response_body,
  112     97   
                        output,
  113     98   
                    )
  114     99   
                    .map_err(crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::unhandled)?;
  115    100   
                    let output = output.meta(generic);
  116    101   
                    output.build()
  117    102   
                };
  118         -
                if tmp.message.is_none() {
  119         -
                    tmp.message = _error_message;
  120         -
                }
  121    103   
                tmp
  122    104   
            })
  123    105   
        }
  124    106   
        "TableInUseException" => crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::TableInUseException({
  125    107   
            #[allow(unused_mut)]
  126    108   
            let mut tmp = {
  127    109   
                #[allow(unused_mut)]
  128    110   
                let mut output = crate::types::error::builders::TableInUseExceptionBuilder::default();
  129    111   
                output = crate::protocol_serde::shape_table_in_use_exception::de_table_in_use_exception_json_err(_response_body, output)
  130    112   
                    .map_err(crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::unhandled)?;
  131    113   
                let output = output.meta(generic);
  132    114   
                output.build()
  133    115   
            };
  134         -
            if tmp.message.is_none() {
  135         -
                tmp.message = _error_message;
  136         -
            }
  137    116   
            tmp
  138    117   
        }),
  139    118   
        "TableNotFoundException" => crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::TableNotFoundException({
  140    119   
            #[allow(unused_mut)]
  141    120   
            let mut tmp = {
  142    121   
                #[allow(unused_mut)]
  143    122   
                let mut output = crate::types::error::builders::TableNotFoundExceptionBuilder::default();
  144    123   
                output = crate::protocol_serde::shape_table_not_found_exception::de_table_not_found_exception_json_err(_response_body, output)
  145    124   
                    .map_err(crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::unhandled)?;
  146    125   
                let output = output.meta(generic);
  147    126   
                output.build()
  148    127   
            };
  149         -
            if tmp.message.is_none() {
  150         -
                tmp.message = _error_message;
  151         -
            }
  152    128   
            tmp
  153    129   
        }),
  154    130   
        _ => crate::operation::restore_table_to_point_in_time::RestoreTableToPointInTimeError::generic(generic),
  155    131   
    })
  156    132   
}
  157    133   
  158    134   
#[allow(clippy::unnecessary_wraps)]
  159    135   
pub fn de_restore_table_to_point_in_time_http_response(
  160    136   
    _response_status: u16,
  161    137   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +123,108 @@
   20     20   
        "InternalServerError" => crate::operation::scan::ScanError::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::scan::ScanError::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::scan::ScanError::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::scan::ScanError::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   
        "ProvisionedThroughputExceededException" => {
   51     45   
            crate::operation::scan::ScanError::ProvisionedThroughputExceededException({
   52     46   
                #[allow(unused_mut)]
   53     47   
                let mut tmp = {
   54     48   
                    #[allow(unused_mut)]
   55     49   
                    let mut output = crate::types::error::builders::ProvisionedThroughputExceededExceptionBuilder::default();
   56     50   
                    output = crate::protocol_serde::shape_provisioned_throughput_exceeded_exception::de_provisioned_throughput_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::scan::ScanError::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   
        }
   66     57   
        "RequestLimitExceeded" => crate::operation::scan::ScanError::RequestLimitExceeded({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::scan::ScanError::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   
        "ResourceNotFoundException" => crate::operation::scan::ScanError::ResourceNotFoundException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   87     75   
                    .map_err(crate::operation::scan::ScanError::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   
        _ => crate::operation::scan::ScanError::generic(generic),
   97     82   
    })
   98     83   
}
   99     84   
  100     85   
#[allow(clippy::unnecessary_wraps)]
  101     86   
pub fn de_scan_http_response(
  102     87   
    _response_status: u16,
  103     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +121,106 @@
   20     20   
        "InternalServerError" => crate::operation::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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::tag_resource::TagResourceError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_tag_resource_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_transact_get_items.rs

@@ -1,1 +139,121 @@
   20     20   
        "InternalServerError" => crate::operation::transact_get_items::TransactGetItemsError::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::transact_get_items::TransactGetItemsError::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::transact_get_items::TransactGetItemsError::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::transact_get_items::TransactGetItemsError::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   
        "ProvisionedThroughputExceededException" => {
   51     45   
            crate::operation::transact_get_items::TransactGetItemsError::ProvisionedThroughputExceededException({
   52     46   
                #[allow(unused_mut)]
   53     47   
                let mut tmp = {
   54     48   
                    #[allow(unused_mut)]
   55     49   
                    let mut output = crate::types::error::builders::ProvisionedThroughputExceededExceptionBuilder::default();
   56     50   
                    output = crate::protocol_serde::shape_provisioned_throughput_exceeded_exception::de_provisioned_throughput_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::transact_get_items::TransactGetItemsError::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   
        }
   66     57   
        "RequestLimitExceeded" => crate::operation::transact_get_items::TransactGetItemsError::RequestLimitExceeded({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::transact_get_items::TransactGetItemsError::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   
        "ResourceNotFoundException" => crate::operation::transact_get_items::TransactGetItemsError::ResourceNotFoundException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   87     75   
                    .map_err(crate::operation::transact_get_items::TransactGetItemsError::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   
        "TransactionCanceledException" => crate::operation::transact_get_items::TransactGetItemsError::TransactionCanceledException({
   97     82   
            #[allow(unused_mut)]
   98     83   
            let mut tmp = {
   99     84   
                #[allow(unused_mut)]
  100     85   
                let mut output = crate::types::error::builders::TransactionCanceledExceptionBuilder::default();
  101     86   
                output =
  102     87   
                    crate::protocol_serde::shape_transaction_canceled_exception::de_transaction_canceled_exception_json_err(_response_body, output)
  103     88   
                        .map_err(crate::operation::transact_get_items::TransactGetItemsError::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   
        _ => crate::operation::transact_get_items::TransactGetItemsError::generic(generic),
  113     95   
    })
  114     96   
}
  115     97   
  116     98   
#[allow(clippy::unnecessary_wraps)]
  117     99   
pub fn de_transact_get_items_http_response(
  118    100   
    _response_status: u16,
  119    101   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -8,8 +181,157 @@
   28     28   
                    let mut output = crate::types::error::builders::IdempotentParameterMismatchExceptionBuilder::default();
   29     29   
                    output =
   30     30   
                        crate::protocol_serde::shape_idempotent_parameter_mismatch_exception::de_idempotent_parameter_mismatch_exception_json_err(
   31     31   
                            _response_body,
   32     32   
                            output,
   33     33   
                        )
   34     34   
                        .map_err(crate::operation::transact_write_items::TransactWriteItemsError::unhandled)?;
   35     35   
                    let output = output.meta(generic);
   36     36   
                    output.build()
   37     37   
                };
   38         -
                if tmp.message.is_none() {
   39         -
                    tmp.message = _error_message;
   40         -
                }
   41     38   
                tmp
   42     39   
            })
   43     40   
        }
   44     41   
        "InternalServerError" => crate::operation::transact_write_items::TransactWriteItemsError::InternalServerError({
   45     42   
            #[allow(unused_mut)]
   46     43   
            let mut tmp = {
   47     44   
                #[allow(unused_mut)]
   48     45   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   49     46   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   50     47   
                    .map_err(crate::operation::transact_write_items::TransactWriteItemsError::unhandled)?;
   51     48   
                let output = output.meta(generic);
   52     49   
                output.build()
   53     50   
            };
   54         -
            if tmp.message.is_none() {
   55         -
                tmp.message = _error_message;
   56         -
            }
   57     51   
            tmp
   58     52   
        }),
   59     53   
        "InvalidEndpointException" => crate::operation::transact_write_items::TransactWriteItemsError::InvalidEndpointException({
   60     54   
            #[allow(unused_mut)]
   61     55   
            let mut tmp = {
   62     56   
                #[allow(unused_mut)]
   63     57   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   64     58   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   65     59   
                    .map_err(crate::operation::transact_write_items::TransactWriteItemsError::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   
        "ProvisionedThroughputExceededException" => {
   75     66   
            crate::operation::transact_write_items::TransactWriteItemsError::ProvisionedThroughputExceededException({
   76     67   
                #[allow(unused_mut)]
   77     68   
                let mut tmp = {
   78     69   
                    #[allow(unused_mut)]
   79     70   
                    let mut output = crate::types::error::builders::ProvisionedThroughputExceededExceptionBuilder::default();
   80     71   
                    output = crate::protocol_serde::shape_provisioned_throughput_exceeded_exception::de_provisioned_throughput_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::transact_write_items::TransactWriteItemsError::unhandled)?;
   81     72   
                    let output = output.meta(generic);
   82     73   
                    output.build()
   83     74   
                };
   84         -
                if tmp.message.is_none() {
   85         -
                    tmp.message = _error_message;
   86         -
                }
   87     75   
                tmp
   88     76   
            })
   89     77   
        }
   90     78   
        "RequestLimitExceeded" => crate::operation::transact_write_items::TransactWriteItemsError::RequestLimitExceeded({
   91     79   
            #[allow(unused_mut)]
   92     80   
            let mut tmp = {
   93     81   
                #[allow(unused_mut)]
   94     82   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
   95     83   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
   96     84   
                    .map_err(crate::operation::transact_write_items::TransactWriteItemsError::unhandled)?;
   97     85   
                let output = output.meta(generic);
   98     86   
                output.build()
   99     87   
            };
  100         -
            if tmp.message.is_none() {
  101         -
                tmp.message = _error_message;
  102         -
            }
  103     88   
            tmp
  104     89   
        }),
  105     90   
        "ResourceNotFoundException" => crate::operation::transact_write_items::TransactWriteItemsError::ResourceNotFoundException({
  106     91   
            #[allow(unused_mut)]
  107     92   
            let mut tmp = {
  108     93   
                #[allow(unused_mut)]
  109     94   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
  110     95   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  111     96   
                    .map_err(crate::operation::transact_write_items::TransactWriteItemsError::unhandled)?;
  112     97   
                let output = output.meta(generic);
  113     98   
                output.build()
  114     99   
            };
  115         -
            if tmp.message.is_none() {
  116         -
                tmp.message = _error_message;
  117         -
            }
  118    100   
            tmp
  119    101   
        }),
  120    102   
        "TransactionCanceledException" => crate::operation::transact_write_items::TransactWriteItemsError::TransactionCanceledException({
  121    103   
            #[allow(unused_mut)]
  122    104   
            let mut tmp = {
  123    105   
                #[allow(unused_mut)]
  124    106   
                let mut output = crate::types::error::builders::TransactionCanceledExceptionBuilder::default();
  125    107   
                output =
  126    108   
                    crate::protocol_serde::shape_transaction_canceled_exception::de_transaction_canceled_exception_json_err(_response_body, output)
  127    109   
                        .map_err(crate::operation::transact_write_items::TransactWriteItemsError::unhandled)?;
  128    110   
                let output = output.meta(generic);
  129    111   
                output.build()
  130    112   
            };
  131         -
            if tmp.message.is_none() {
  132         -
                tmp.message = _error_message;
  133         -
            }
  134    113   
            tmp
  135    114   
        }),
  136    115   
        "TransactionInProgressException" => crate::operation::transact_write_items::TransactWriteItemsError::TransactionInProgressException({
  137    116   
            #[allow(unused_mut)]
  138    117   
            let mut tmp = {
  139    118   
                #[allow(unused_mut)]
  140    119   
                let mut output = crate::types::error::builders::TransactionInProgressExceptionBuilder::default();
  141    120   
                output = crate::protocol_serde::shape_transaction_in_progress_exception::de_transaction_in_progress_exception_json_err(
  142    121   
                    _response_body,
  143    122   
                    output,
  144    123   
                )
  145    124   
                .map_err(crate::operation::transact_write_items::TransactWriteItemsError::unhandled)?;
  146    125   
                let output = output.meta(generic);
  147    126   
                output.build()
  148    127   
            };
  149         -
            if tmp.message.is_none() {
  150         -
                tmp.message = _error_message;
  151         -
            }
  152    128   
            tmp
  153    129   
        }),
  154    130   
        _ => crate::operation::transact_write_items::TransactWriteItemsError::generic(generic),
  155    131   
    })
  156    132   
}
  157    133   
  158    134   
#[allow(clippy::unnecessary_wraps)]
  159    135   
pub fn de_transact_write_items_http_response(
  160    136   
    _response_status: u16,
  161    137   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +121,106 @@
   20     20   
        "InternalServerError" => crate::operation::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_untag_resource_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_update_continuous_backups.rs

@@ -12,12 +120,108 @@
   32     32   
                    let mut output = crate::types::error::builders::ContinuousBackupsUnavailableExceptionBuilder::default();
   33     33   
                    output =
   34     34   
                        crate::protocol_serde::shape_continuous_backups_unavailable_exception::de_continuous_backups_unavailable_exception_json_err(
   35     35   
                            _response_body,
   36     36   
                            output,
   37     37   
                        )
   38     38   
                        .map_err(crate::operation::update_continuous_backups::UpdateContinuousBackupsError::unhandled)?;
   39     39   
                    let output = output.meta(generic);
   40     40   
                    output.build()
   41     41   
                };
   42         -
                if tmp.message.is_none() {
   43         -
                    tmp.message = _error_message;
   44         -
                }
   45     42   
                tmp
   46     43   
            })
   47     44   
        }
   48     45   
        "InternalServerError" => crate::operation::update_continuous_backups::UpdateContinuousBackupsError::InternalServerError({
   49     46   
            #[allow(unused_mut)]
   50     47   
            let mut tmp = {
   51     48   
                #[allow(unused_mut)]
   52     49   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   53     50   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   54     51   
                    .map_err(crate::operation::update_continuous_backups::UpdateContinuousBackupsError::unhandled)?;
   55     52   
                let output = output.meta(generic);
   56     53   
                output.build()
   57     54   
            };
   58         -
            if tmp.message.is_none() {
   59         -
                tmp.message = _error_message;
   60         -
            }
   61     55   
            tmp
   62     56   
        }),
   63     57   
        "InvalidEndpointException" => crate::operation::update_continuous_backups::UpdateContinuousBackupsError::InvalidEndpointException({
   64     58   
            #[allow(unused_mut)]
   65     59   
            let mut tmp = {
   66     60   
                #[allow(unused_mut)]
   67     61   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   68     62   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   69     63   
                    .map_err(crate::operation::update_continuous_backups::UpdateContinuousBackupsError::unhandled)?;
   70     64   
                let output = output.meta(generic);
   71     65   
                output.build()
   72     66   
            };
   73         -
            if tmp.message.is_none() {
   74         -
                tmp.message = _error_message;
   75         -
            }
   76     67   
            tmp
   77     68   
        }),
   78     69   
        "TableNotFoundException" => crate::operation::update_continuous_backups::UpdateContinuousBackupsError::TableNotFoundException({
   79     70   
            #[allow(unused_mut)]
   80     71   
            let mut tmp = {
   81     72   
                #[allow(unused_mut)]
   82     73   
                let mut output = crate::types::error::builders::TableNotFoundExceptionBuilder::default();
   83     74   
                output = crate::protocol_serde::shape_table_not_found_exception::de_table_not_found_exception_json_err(_response_body, output)
   84     75   
                    .map_err(crate::operation::update_continuous_backups::UpdateContinuousBackupsError::unhandled)?;
   85     76   
                let output = output.meta(generic);
   86     77   
                output.build()
   87     78   
            };
   88         -
            if tmp.message.is_none() {
   89         -
                tmp.message = _error_message;
   90         -
            }
   91     79   
            tmp
   92     80   
        }),
   93     81   
        _ => crate::operation::update_continuous_backups::UpdateContinuousBackupsError::generic(generic),
   94     82   
    })
   95     83   
}
   96     84   
   97     85   
#[allow(clippy::unnecessary_wraps)]
   98     86   
pub fn de_update_continuous_backups_http_response(
   99     87   
    _response_status: u16,
  100     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +84,78 @@
   27     27   
        "InternalServerError" => crate::operation::update_contributor_insights::UpdateContributorInsightsError::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::update_contributor_insights::UpdateContributorInsightsError::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   
        "ResourceNotFoundException" => crate::operation::update_contributor_insights::UpdateContributorInsightsError::ResourceNotFoundException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::update_contributor_insights::UpdateContributorInsightsError::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   
        _ => crate::operation::update_contributor_insights::UpdateContributorInsightsError::generic(generic),
   58     52   
    })
   59     53   
}
   60     54   
   61     55   
#[allow(clippy::unnecessary_wraps)]
   62     56   
pub fn de_update_contributor_insights_http_response(
   63     57   
    _response_status: u16,
   64     58   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -4,4 +144,126 @@
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::GlobalTableNotFoundExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_global_table_not_found_exception::de_global_table_not_found_exception_json_err(
   27     27   
                    _response_body,
   28     28   
                    output,
   29     29   
                )
   30     30   
                .map_err(crate::operation::update_global_table::UpdateGlobalTableError::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   
        "InternalServerError" => crate::operation::update_global_table::UpdateGlobalTableError::InternalServerError({
   40     37   
            #[allow(unused_mut)]
   41     38   
            let mut tmp = {
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   44     41   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   45     42   
                    .map_err(crate::operation::update_global_table::UpdateGlobalTableError::unhandled)?;
   46     43   
                let output = output.meta(generic);
   47     44   
                output.build()
   48     45   
            };
   49         -
            if tmp.message.is_none() {
   50         -
                tmp.message = _error_message;
   51         -
            }
   52     46   
            tmp
   53     47   
        }),
   54     48   
        "InvalidEndpointException" => crate::operation::update_global_table::UpdateGlobalTableError::InvalidEndpointException({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   60     54   
                    .map_err(crate::operation::update_global_table::UpdateGlobalTableError::unhandled)?;
   61     55   
                let output = output.meta(generic);
   62     56   
                output.build()
   63     57   
            };
   64         -
            if tmp.message.is_none() {
   65         -
                tmp.message = _error_message;
   66         -
            }
   67     58   
            tmp
   68     59   
        }),
   69     60   
        "ReplicaAlreadyExistsException" => crate::operation::update_global_table::UpdateGlobalTableError::ReplicaAlreadyExistsException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::ReplicaAlreadyExistsExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_replica_already_exists_exception::de_replica_already_exists_exception_json_err(
   75     66   
                    _response_body,
   76     67   
                    output,
   77     68   
                )
   78     69   
                .map_err(crate::operation::update_global_table::UpdateGlobalTableError::unhandled)?;
   79     70   
                let output = output.meta(generic);
   80     71   
                output.build()
   81     72   
            };
   82         -
            if tmp.message.is_none() {
   83         -
                tmp.message = _error_message;
   84         -
            }
   85     73   
            tmp
   86     74   
        }),
   87     75   
        "ReplicaNotFoundException" => crate::operation::update_global_table::UpdateGlobalTableError::ReplicaNotFoundException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::ReplicaNotFoundExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_replica_not_found_exception::de_replica_not_found_exception_json_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::update_global_table::UpdateGlobalTableError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        "TableNotFoundException" => crate::operation::update_global_table::UpdateGlobalTableError::TableNotFoundException({
  103     88   
            #[allow(unused_mut)]
  104     89   
            let mut tmp = {
  105     90   
                #[allow(unused_mut)]
  106     91   
                let mut output = crate::types::error::builders::TableNotFoundExceptionBuilder::default();
  107     92   
                output = crate::protocol_serde::shape_table_not_found_exception::de_table_not_found_exception_json_err(_response_body, output)
  108     93   
                    .map_err(crate::operation::update_global_table::UpdateGlobalTableError::unhandled)?;
  109     94   
                let output = output.meta(generic);
  110     95   
                output.build()
  111     96   
            };
  112         -
            if tmp.message.is_none() {
  113         -
                tmp.message = _error_message;
  114         -
            }
  115     97   
            tmp
  116     98   
        }),
  117     99   
        _ => crate::operation::update_global_table::UpdateGlobalTableError::generic(generic),
  118    100   
    })
  119    101   
}
  120    102   
  121    103   
#[allow(clippy::unnecessary_wraps)]
  122    104   
pub fn de_update_global_table_http_response(
  123    105   
    _response_status: u16,
  124    106   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -11,11 +164,143 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::GlobalTableNotFoundExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_global_table_not_found_exception::de_global_table_not_found_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::unhandled)?;
   38     38   
                    let output = output.meta(generic);
   39     39   
                    output.build()
   40     40   
                };
   41         -
                if tmp.message.is_none() {
   42         -
                    tmp.message = _error_message;
   43         -
                }
   44     41   
                tmp
   45     42   
            })
   46     43   
        }
   47     44   
        "IndexNotFoundException" => crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::IndexNotFoundException({
   48     45   
            #[allow(unused_mut)]
   49     46   
            let mut tmp = {
   50     47   
                #[allow(unused_mut)]
   51     48   
                let mut output = crate::types::error::builders::IndexNotFoundExceptionBuilder::default();
   52     49   
                output = crate::protocol_serde::shape_index_not_found_exception::de_index_not_found_exception_json_err(_response_body, output)
   53     50   
                    .map_err(crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::unhandled)?;
   54     51   
                let output = output.meta(generic);
   55     52   
                output.build()
   56     53   
            };
   57         -
            if tmp.message.is_none() {
   58         -
                tmp.message = _error_message;
   59         -
            }
   60     54   
            tmp
   61     55   
        }),
   62     56   
        "InternalServerError" => crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::InternalServerError({
   63     57   
            #[allow(unused_mut)]
   64     58   
            let mut tmp = {
   65     59   
                #[allow(unused_mut)]
   66     60   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   67     61   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   68     62   
                    .map_err(crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::unhandled)?;
   69     63   
                let output = output.meta(generic);
   70     64   
                output.build()
   71     65   
            };
   72         -
            if tmp.message.is_none() {
   73         -
                tmp.message = _error_message;
   74         -
            }
   75     66   
            tmp
   76     67   
        }),
   77     68   
        "InvalidEndpointException" => crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::InvalidEndpointException({
   78     69   
            #[allow(unused_mut)]
   79     70   
            let mut tmp = {
   80     71   
                #[allow(unused_mut)]
   81     72   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   82     73   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   83     74   
                    .map_err(crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::unhandled)?;
   84     75   
                let output = output.meta(generic);
   85     76   
                output.build()
   86     77   
            };
   87         -
            if tmp.message.is_none() {
   88         -
                tmp.message = _error_message;
   89         -
            }
   90     78   
            tmp
   91     79   
        }),
   92     80   
        "LimitExceededException" => crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::LimitExceededException({
   93     81   
            #[allow(unused_mut)]
   94     82   
            let mut tmp = {
   95     83   
                #[allow(unused_mut)]
   96     84   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   97     85   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   98     86   
                    .map_err(crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::unhandled)?;
   99     87   
                let output = output.meta(generic);
  100     88   
                output.build()
  101     89   
            };
  102         -
            if tmp.message.is_none() {
  103         -
                tmp.message = _error_message;
  104         -
            }
  105     90   
            tmp
  106     91   
        }),
  107     92   
        "ReplicaNotFoundException" => crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::ReplicaNotFoundException({
  108     93   
            #[allow(unused_mut)]
  109     94   
            let mut tmp = {
  110     95   
                #[allow(unused_mut)]
  111     96   
                let mut output = crate::types::error::builders::ReplicaNotFoundExceptionBuilder::default();
  112     97   
                output = crate::protocol_serde::shape_replica_not_found_exception::de_replica_not_found_exception_json_err(_response_body, output)
  113     98   
                    .map_err(crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::unhandled)?;
  114     99   
                let output = output.meta(generic);
  115    100   
                output.build()
  116    101   
            };
  117         -
            if tmp.message.is_none() {
  118         -
                tmp.message = _error_message;
  119         -
            }
  120    102   
            tmp
  121    103   
        }),
  122    104   
        "ResourceInUseException" => crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::ResourceInUseException({
  123    105   
            #[allow(unused_mut)]
  124    106   
            let mut tmp = {
  125    107   
                #[allow(unused_mut)]
  126    108   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
  127    109   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
  128    110   
                    .map_err(crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::unhandled)?;
  129    111   
                let output = output.meta(generic);
  130    112   
                output.build()
  131    113   
            };
  132         -
            if tmp.message.is_none() {
  133         -
                tmp.message = _error_message;
  134         -
            }
  135    114   
            tmp
  136    115   
        }),
  137    116   
        _ => crate::operation::update_global_table_settings::UpdateGlobalTableSettingsError::generic(generic),
  138    117   
    })
  139    118   
}
  140    119   
  141    120   
#[allow(clippy::unnecessary_wraps)]
  142    121   
pub fn de_update_global_table_settings_http_response(
  143    122   
    _response_status: u16,
  144    123   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_update_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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::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::update_item::UpdateItemError::generic(generic),
  145    121   
    })
  146    122   
}
  147    123   
  148    124   
#[allow(clippy::unnecessary_wraps)]
  149    125   
pub fn de_update_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_update_kinesis_streaming_destination.rs

@@ -4,4 +135,120 @@
   24     24   
            crate::operation::update_kinesis_streaming_destination::UpdateKinesisStreamingDestinationError::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::update_kinesis_streaming_destination::UpdateKinesisStreamingDestinationError::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::update_kinesis_streaming_destination::UpdateKinesisStreamingDestinationError::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::update_kinesis_streaming_destination::UpdateKinesisStreamingDestinationError::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   
        "LimitExceededException" => {
   58     52   
            crate::operation::update_kinesis_streaming_destination::UpdateKinesisStreamingDestinationError::LimitExceededException({
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut tmp = {
   61     55   
                    #[allow(unused_mut)]
   62     56   
                    let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   63     57   
                    output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   64     58   
                        .map_err(crate::operation::update_kinesis_streaming_destination::UpdateKinesisStreamingDestinationError::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   
        }
   74     65   
        "ResourceInUseException" => {
   75     66   
            crate::operation::update_kinesis_streaming_destination::UpdateKinesisStreamingDestinationError::ResourceInUseException({
   76     67   
                #[allow(unused_mut)]
   77     68   
                let mut tmp = {
   78     69   
                    #[allow(unused_mut)]
   79     70   
                    let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   80     71   
                    output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   81     72   
                        .map_err(crate::operation::update_kinesis_streaming_destination::UpdateKinesisStreamingDestinationError::unhandled)?;
   82     73   
                    let output = output.meta(generic);
   83     74   
                    output.build()
   84     75   
                };
   85         -
                if tmp.message.is_none() {
   86         -
                    tmp.message = _error_message;
   87         -
                }
   88     76   
                tmp
   89     77   
            })
   90     78   
        }
   91     79   
        "ResourceNotFoundException" => {
   92     80   
            crate::operation::update_kinesis_streaming_destination::UpdateKinesisStreamingDestinationError::ResourceNotFoundException({
   93     81   
                #[allow(unused_mut)]
   94     82   
                let mut tmp = {
   95     83   
                    #[allow(unused_mut)]
   96     84   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   97     85   
                    output =
   98     86   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   99     87   
                            .map_err(crate::operation::update_kinesis_streaming_destination::UpdateKinesisStreamingDestinationError::unhandled)?;
  100     88   
                    let output = output.meta(generic);
  101     89   
                    output.build()
  102     90   
                };
  103         -
                if tmp.message.is_none() {
  104         -
                    tmp.message = _error_message;
  105         -
                }
  106     91   
                tmp
  107     92   
            })
  108     93   
        }
  109     94   
        _ => crate::operation::update_kinesis_streaming_destination::UpdateKinesisStreamingDestinationError::generic(generic),
  110     95   
    })
  111     96   
}
  112     97   
  113     98   
#[allow(clippy::unnecessary_wraps)]
  114     99   
pub fn de_update_kinesis_streaming_destination_http_response(
  115    100   
    _response_status: u16,

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

@@ -1,1 +122,107 @@
   20     20   
        "InternalServerError" => crate::operation::update_table::UpdateTableError::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::update_table::UpdateTableError::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::update_table::UpdateTableError::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::update_table::UpdateTableError::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::update_table::UpdateTableError::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::update_table::UpdateTableError::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::update_table::UpdateTableError::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::update_table::UpdateTableError::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::update_table::UpdateTableError::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::update_table::UpdateTableError::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::update_table::UpdateTableError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_update_table_http_response(
  101     86   
    _response_status: u16,
  102     87   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,