AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05

Files changed:

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_put_stored_query.rs

@@ -1,1 +93,84 @@
   20     20   
        "ResourceConcurrentModificationException" => {
   21     21   
            crate::operation::put_stored_query::PutStoredQueryError::ResourceConcurrentModificationException({
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut tmp = {
   24     24   
                    #[allow(unused_mut)]
   25     25   
                    let mut output = crate::types::error::builders::ResourceConcurrentModificationExceptionBuilder::default();
   26     26   
                    output = crate::protocol_serde::shape_resource_concurrent_modification_exception::de_resource_concurrent_modification_exception_json_err(_response_body, output).map_err(crate::operation::put_stored_query::PutStoredQueryError::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   
        }
   36     33   
        "TooManyTagsException" => crate::operation::put_stored_query::PutStoredQueryError::TooManyTagsException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::TooManyTagsExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_too_many_tags_exception::de_too_many_tags_exception_json_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::put_stored_query::PutStoredQueryError::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   
        "ValidationException" => crate::operation::put_stored_query::PutStoredQueryError::ValidationException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::put_stored_query::PutStoredQueryError::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   
        _ => crate::operation::put_stored_query::PutStoredQueryError::generic(generic),
   67     58   
    })
   68     59   
}
   69     60   
   70     61   
#[allow(clippy::unnecessary_wraps)]
   71     62   
pub fn de_put_stored_query_http_response(
   72     63   
    _response_status: u16,
   73     64   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_select_aggregate_resource_config.rs

@@ -5,5 +116,104 @@
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidExpressionExceptionBuilder::default();
   29     29   
                    output =
   30     30   
                        crate::protocol_serde::shape_invalid_expression_exception::de_invalid_expression_exception_json_err(_response_body, output)
   31     31   
                            .map_err(crate::operation::select_aggregate_resource_config::SelectAggregateResourceConfigError::unhandled)?;
   32     32   
                    let output = output.meta(generic);
   33     33   
                    output.build()
   34     34   
                };
   35         -
                if tmp.message.is_none() {
   36         -
                    tmp.message = _error_message;
   37         -
                }
   38     35   
                tmp
   39     36   
            })
   40     37   
        }
   41     38   
        "InvalidLimitException" => crate::operation::select_aggregate_resource_config::SelectAggregateResourceConfigError::InvalidLimitException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::InvalidLimitExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_invalid_limit_exception::de_invalid_limit_exception_json_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::select_aggregate_resource_config::SelectAggregateResourceConfigError::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   
        "InvalidNextTokenException" => {
   57     51   
            crate::operation::select_aggregate_resource_config::SelectAggregateResourceConfigError::InvalidNextTokenException({
   58     52   
                #[allow(unused_mut)]
   59     53   
                let mut tmp = {
   60     54   
                    #[allow(unused_mut)]
   61     55   
                    let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   62     56   
                    output =
   63     57   
                        crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   64     58   
                            .map_err(crate::operation::select_aggregate_resource_config::SelectAggregateResourceConfigError::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   
        "NoSuchConfigurationAggregatorException" => {
   75     66   
            crate::operation::select_aggregate_resource_config::SelectAggregateResourceConfigError::NoSuchConfigurationAggregatorException({
   76     67   
                #[allow(unused_mut)]
   77     68   
                let mut tmp = {
   78     69   
                    #[allow(unused_mut)]
   79     70   
                    let mut output = crate::types::error::builders::NoSuchConfigurationAggregatorExceptionBuilder::default();
   80     71   
                    output = crate::protocol_serde::shape_no_such_configuration_aggregator_exception::de_no_such_configuration_aggregator_exception_json_err(_response_body, output).map_err(crate::operation::select_aggregate_resource_config::SelectAggregateResourceConfigError::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   
        _ => crate::operation::select_aggregate_resource_config::SelectAggregateResourceConfigError::generic(generic),
   91     79   
    })
   92     80   
}
   93     81   
   94     82   
#[allow(clippy::unnecessary_wraps)]
   95     83   
pub fn de_select_aggregate_resource_config_http_response(
   96     84   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_select_resource_config.rs

@@ -3,3 +95,86 @@
   23     23   
        "InvalidExpressionException" => crate::operation::select_resource_config::SelectResourceConfigError::InvalidExpressionException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidExpressionExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_expression_exception::de_invalid_expression_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::select_resource_config::SelectResourceConfigError::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   
        "InvalidLimitException" => crate::operation::select_resource_config::SelectResourceConfigError::InvalidLimitException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidLimitExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_limit_exception::de_invalid_limit_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::select_resource_config::SelectResourceConfigError::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   
        "InvalidNextTokenException" => crate::operation::select_resource_config::SelectResourceConfigError::InvalidNextTokenException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::select_resource_config::SelectResourceConfigError::unhandled)?;
   60     54   
                let output = output.meta(generic);
   61     55   
                output.build()
   62     56   
            };
   63         -
            if tmp.message.is_none() {
   64         -
                tmp.message = _error_message;
   65         -
            }
   66     57   
            tmp
   67     58   
        }),
   68     59   
        _ => crate::operation::select_resource_config::SelectResourceConfigError::generic(generic),
   69     60   
    })
   70     61   
}
   71     62   
   72     63   
#[allow(clippy::unnecessary_wraps)]
   73     64   
pub fn de_select_resource_config_http_response(
   74     65   
    _response_status: u16,
   75     66   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_start_config_rules_evaluation.rs

@@ -7,7 +116,104 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::start_config_rules_evaluation::StartConfigRulesEvaluationError::unhandled)?;
   34     34   
                    let output = output.meta(generic);
   35     35   
                    output.build()
   36     36   
                };
   37         -
                if tmp.message.is_none() {
   38         -
                    tmp.message = _error_message;
   39         -
                }
   40     37   
                tmp
   41     38   
            })
   42     39   
        }
   43     40   
        "LimitExceededException" => crate::operation::start_config_rules_evaluation::StartConfigRulesEvaluationError::LimitExceededException({
   44     41   
            #[allow(unused_mut)]
   45     42   
            let mut tmp = {
   46     43   
                #[allow(unused_mut)]
   47     44   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   48     45   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   49     46   
                    .map_err(crate::operation::start_config_rules_evaluation::StartConfigRulesEvaluationError::unhandled)?;
   50     47   
                let output = output.meta(generic);
   51     48   
                output.build()
   52     49   
            };
   53         -
            if tmp.message.is_none() {
   54         -
                tmp.message = _error_message;
   55         -
            }
   56     50   
            tmp
   57     51   
        }),
   58     52   
        "NoSuchConfigRuleException" => crate::operation::start_config_rules_evaluation::StartConfigRulesEvaluationError::NoSuchConfigRuleException({
   59     53   
            #[allow(unused_mut)]
   60     54   
            let mut tmp = {
   61     55   
                #[allow(unused_mut)]
   62     56   
                let mut output = crate::types::error::builders::NoSuchConfigRuleExceptionBuilder::default();
   63     57   
                output =
   64     58   
                    crate::protocol_serde::shape_no_such_config_rule_exception::de_no_such_config_rule_exception_json_err(_response_body, output)
   65     59   
                        .map_err(crate::operation::start_config_rules_evaluation::StartConfigRulesEvaluationError::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   
        "ResourceInUseException" => crate::operation::start_config_rules_evaluation::StartConfigRulesEvaluationError::ResourceInUseException({
   75     66   
            #[allow(unused_mut)]
   76     67   
            let mut tmp = {
   77     68   
                #[allow(unused_mut)]
   78     69   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   79     70   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   80     71   
                    .map_err(crate::operation::start_config_rules_evaluation::StartConfigRulesEvaluationError::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   
        _ => crate::operation::start_config_rules_evaluation::StartConfigRulesEvaluationError::generic(generic),
   90     78   
    })
   91     79   
}
   92     80   
   93     81   
#[allow(clippy::unnecessary_wraps)]
   94     82   
pub fn de_start_config_rules_evaluation_http_response(
   95     83   
    _response_status: u16,
   96     84   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_start_configuration_recorder.rs

@@ -8,8 +91,85 @@
   28     28   
                    let mut output = crate::types::error::builders::NoAvailableDeliveryChannelExceptionBuilder::default();
   29     29   
                    output =
   30     30   
                        crate::protocol_serde::shape_no_available_delivery_channel_exception::de_no_available_delivery_channel_exception_json_err(
   31     31   
                            _response_body,
   32     32   
                            output,
   33     33   
                        )
   34     34   
                        .map_err(crate::operation::start_configuration_recorder::StartConfigurationRecorderError::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   
        "NoSuchConfigurationRecorderException" => {
   45     42   
            crate::operation::start_configuration_recorder::StartConfigurationRecorderError::NoSuchConfigurationRecorderException({
   46     43   
                #[allow(unused_mut)]
   47     44   
                let mut tmp = {
   48     45   
                    #[allow(unused_mut)]
   49     46   
                    let mut output = crate::types::error::builders::NoSuchConfigurationRecorderExceptionBuilder::default();
   50     47   
                    output =
   51     48   
                        crate::protocol_serde::shape_no_such_configuration_recorder_exception::de_no_such_configuration_recorder_exception_json_err(
   52     49   
                            _response_body,
   53     50   
                            output,
   54     51   
                        )
   55     52   
                        .map_err(crate::operation::start_configuration_recorder::StartConfigurationRecorderError::unhandled)?;
   56     53   
                    let output = output.meta(generic);
   57     54   
                    output.build()
   58     55   
                };
   59         -
                if tmp.message.is_none() {
   60         -
                    tmp.message = _error_message;
   61         -
                }
   62     56   
                tmp
   63     57   
            })
   64     58   
        }
   65     59   
        _ => crate::operation::start_configuration_recorder::StartConfigurationRecorderError::generic(generic),
   66     60   
    })
   67     61   
}
   68     62   
   69     63   
#[allow(clippy::unnecessary_wraps)]
   70     64   
pub fn de_start_configuration_recorder_http_response(
   71     65   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_start_remediation_execution.rs

@@ -11,11 +109,100 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InsufficientPermissionsExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_insufficient_permissions_exception::de_insufficient_permissions_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::start_remediation_execution::StartRemediationExecutionError::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   
        "InvalidParameterValueException" => {
   48     45   
            crate::operation::start_remediation_execution::StartRemediationExecutionError::InvalidParameterValueException({
   49     46   
                #[allow(unused_mut)]
   50     47   
                let mut tmp = {
   51     48   
                    #[allow(unused_mut)]
   52     49   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   53     50   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   54     51   
                        _response_body,
   55     52   
                        output,
   56     53   
                    )
   57     54   
                    .map_err(crate::operation::start_remediation_execution::StartRemediationExecutionError::unhandled)?;
   58     55   
                    let output = output.meta(generic);
   59     56   
                    output.build()
   60     57   
                };
   61         -
                if tmp.message.is_none() {
   62         -
                    tmp.message = _error_message;
   63         -
                }
   64     58   
                tmp
   65     59   
            })
   66     60   
        }
   67     61   
        "NoSuchRemediationConfigurationException" => {
   68     62   
            crate::operation::start_remediation_execution::StartRemediationExecutionError::NoSuchRemediationConfigurationException({
   69     63   
                #[allow(unused_mut)]
   70     64   
                let mut tmp = {
   71     65   
                    #[allow(unused_mut)]
   72     66   
                    let mut output = crate::types::error::builders::NoSuchRemediationConfigurationExceptionBuilder::default();
   73     67   
                    output = crate::protocol_serde::shape_no_such_remediation_configuration_exception::de_no_such_remediation_configuration_exception_json_err(_response_body, output).map_err(crate::operation::start_remediation_execution::StartRemediationExecutionError::unhandled)?;
   74     68   
                    let output = output.meta(generic);
   75     69   
                    output.build()
   76     70   
                };
   77         -
                if tmp.message.is_none() {
   78         -
                    tmp.message = _error_message;
   79         -
                }
   80     71   
                tmp
   81     72   
            })
   82     73   
        }
   83     74   
        _ => crate::operation::start_remediation_execution::StartRemediationExecutionError::generic(generic),
   84     75   
    })
   85     76   
}
   86     77   
   87     78   
#[allow(clippy::unnecessary_wraps)]
   88     79   
pub fn de_start_remediation_execution_http_response(
   89     80   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_start_resource_evaluation.rs

@@ -8,8 +89,83 @@
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::IdempotentParameterMismatchBuilder::default();
   32     32   
                output =
   33     33   
                    crate::protocol_serde::shape_idempotent_parameter_mismatch::de_idempotent_parameter_mismatch_json_err(_response_body, output)
   34     34   
                        .map_err(crate::operation::start_resource_evaluation::StartResourceEvaluationError::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   
        "InvalidParameterValueException" => {
   44     41   
            crate::operation::start_resource_evaluation::StartResourceEvaluationError::InvalidParameterValueException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   49     46   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   50     47   
                        _response_body,
   51     48   
                        output,
   52     49   
                    )
   53     50   
                    .map_err(crate::operation::start_resource_evaluation::StartResourceEvaluationError::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   
        }
   63     57   
        _ => crate::operation::start_resource_evaluation::StartResourceEvaluationError::generic(generic),
   64     58   
    })
   65     59   
}
   66     60   
   67     61   
#[allow(clippy::unnecessary_wraps)]
   68     62   
pub fn de_start_resource_evaluation_http_response(
   69     63   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_stop_configuration_recorder.rs

@@ -12,12 +74,71 @@
   32     32   
                    let mut output = crate::types::error::builders::NoSuchConfigurationRecorderExceptionBuilder::default();
   33     33   
                    output =
   34     34   
                        crate::protocol_serde::shape_no_such_configuration_recorder_exception::de_no_such_configuration_recorder_exception_json_err(
   35     35   
                            _response_body,
   36     36   
                            output,
   37     37   
                        )
   38     38   
                        .map_err(crate::operation::stop_configuration_recorder::StopConfigurationRecorderError::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   
        _ => crate::operation::stop_configuration_recorder::StopConfigurationRecorderError::generic(generic),
   49     46   
    })
   50     47   
}
   51     48   
   52     49   
#[allow(clippy::unnecessary_wraps)]
   53     50   
pub fn de_stop_configuration_recorder_http_response(
   54     51   
    _response_status: u16,

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

@@ -1,1 +91,82 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::tag_resource::TagResourceError::ResourceNotFoundException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_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   
        "TooManyTagsException" => crate::operation::tag_resource::TagResourceError::TooManyTagsException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::TooManyTagsExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_too_many_tags_exception::de_too_many_tags_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   
        "ValidationException" => crate::operation::tag_resource::TagResourceError::ValidationException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_validation_exception::de_validation_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   
        _ => crate::operation::tag_resource::TagResourceError::generic(generic),
   66     57   
    })
   67     58   
}
   68     59   
   69     60   
#[allow(clippy::unnecessary_wraps)]
   70     61   
pub fn de_tag_resource_http_response(
   71     62   
    _response_status: u16,
   72     63   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +76,70 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::untag_resource::UntagResourceError::ResourceNotFoundException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_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   
        "ValidationException" => crate::operation::untag_resource::UntagResourceError::ValidationException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_validation_exception::de_validation_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   
        _ => crate::operation::untag_resource::UntagResourceError::generic(generic),
   51     45   
    })
   52     46   
}
   53     47   
   54     48   
#[allow(clippy::unnecessary_wraps)]
   55     49   
pub fn de_untag_resource_http_response(
   56     50   
    _response_status: u16,
   57     51   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +80,74 @@
   23     23   
        "InternalServerError" => crate::operation::batch_execute_statement::BatchExecuteStatementError::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::batch_execute_statement::BatchExecuteStatementError::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   
        "RequestLimitExceeded" => crate::operation::batch_execute_statement::BatchExecuteStatementError::RequestLimitExceeded({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::batch_execute_statement::BatchExecuteStatementError::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   
        _ => crate::operation::batch_execute_statement::BatchExecuteStatementError::generic(generic),
   54     48   
    })
   55     49   
}
   56     50   
   57     51   
#[allow(clippy::unnecessary_wraps)]
   58     52   
pub fn de_batch_execute_statement_http_response(
   59     53   
    _response_status: u16,
   60     54   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +123,108 @@
   20     20   
        "InternalServerError" => crate::operation::batch_get_item::BatchGetItemError::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::batch_get_item::BatchGetItemError::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::batch_get_item::BatchGetItemError::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::batch_get_item::BatchGetItemError::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::batch_get_item::BatchGetItemError::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::batch_get_item::BatchGetItemError::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::batch_get_item::BatchGetItemError::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::batch_get_item::BatchGetItemError::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::batch_get_item::BatchGetItemError::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::batch_get_item::BatchGetItemError::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::batch_get_item::BatchGetItemError::generic(generic),
   97     82   
    })
   98     83   
}
   99     84   
  100     85   
#[allow(clippy::unnecessary_wraps)]
  101     86   
pub fn de_batch_get_item_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_batch_write_item.rs

@@ -1,1 +139,121 @@
   20     20   
        "InternalServerError" => crate::operation::batch_write_item::BatchWriteItemError::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::batch_write_item::BatchWriteItemError::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::batch_write_item::BatchWriteItemError::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::batch_write_item::BatchWriteItemError::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   
        "ItemCollectionSizeLimitExceededException" => {
   51     45   
            crate::operation::batch_write_item::BatchWriteItemError::ItemCollectionSizeLimitExceededException({
   52     46   
                #[allow(unused_mut)]
   53     47   
                let mut tmp = {
   54     48   
                    #[allow(unused_mut)]
   55     49   
                    let mut output = crate::types::error::builders::ItemCollectionSizeLimitExceededExceptionBuilder::default();
   56     50   
                    output = crate::protocol_serde::shape_item_collection_size_limit_exceeded_exception::de_item_collection_size_limit_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::batch_write_item::BatchWriteItemError::unhandled)?;
   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   
        "ProvisionedThroughputExceededException" => {
   67     58   
            crate::operation::batch_write_item::BatchWriteItemError::ProvisionedThroughputExceededException({
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut tmp = {
   70     61   
                    #[allow(unused_mut)]
   71     62   
                    let mut output = crate::types::error::builders::ProvisionedThroughputExceededExceptionBuilder::default();
   72     63   
                    output = crate::protocol_serde::shape_provisioned_throughput_exceeded_exception::de_provisioned_throughput_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::batch_write_item::BatchWriteItemError::unhandled)?;
   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   
        }
   82     70   
        "RequestLimitExceeded" => crate::operation::batch_write_item::BatchWriteItemError::RequestLimitExceeded({
   83     71   
            #[allow(unused_mut)]
   84     72   
            let mut tmp = {
   85     73   
                #[allow(unused_mut)]
   86     74   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
   87     75   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
   88     76   
                    .map_err(crate::operation::batch_write_item::BatchWriteItemError::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   
        "ResourceNotFoundException" => crate::operation::batch_write_item::BatchWriteItemError::ResourceNotFoundException({
   98     83   
            #[allow(unused_mut)]
   99     84   
            let mut tmp = {
  100     85   
                #[allow(unused_mut)]
  101     86   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
  102     87   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  103     88   
                    .map_err(crate::operation::batch_write_item::BatchWriteItemError::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::batch_write_item::BatchWriteItemError::generic(generic),
  113     95   
    })
  114     96   
}
  115     97   
  116     98   
#[allow(clippy::unnecessary_wraps)]
  117     99   
pub fn de_batch_write_item_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_create_backup.rs

@@ -1,1 +155,134 @@
   20     20   
        "BackupInUseException" => crate::operation::create_backup::CreateBackupError::BackupInUseException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::BackupInUseExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_backup_in_use_exception::de_backup_in_use_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::create_backup::CreateBackupError::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   
        "ContinuousBackupsUnavailableException" => crate::operation::create_backup::CreateBackupError::ContinuousBackupsUnavailableException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ContinuousBackupsUnavailableExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_continuous_backups_unavailable_exception::de_continuous_backups_unavailable_exception_json_err(
   41     38   
                    _response_body,
   42     39   
                    output,
   43     40   
                )
   44     41   
                .map_err(crate::operation::create_backup::CreateBackupError::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   
        "InternalServerError" => crate::operation::create_backup::CreateBackupError::InternalServerError({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::create_backup::CreateBackupError::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   
        "InvalidEndpointException" => crate::operation::create_backup::CreateBackupError::InvalidEndpointException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::create_backup::CreateBackupError::unhandled)?;
   75     66   
                let output = output.meta(generic);
   76     67   
                output.build()
   77     68   
            };
   78         -
            if tmp.message.is_none() {
   79         -
                tmp.message = _error_message;
   80         -
            }
   81     69   
            tmp
   82     70   
        }),
   83     71   
        "LimitExceededException" => crate::operation::create_backup::CreateBackupError::LimitExceededException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::create_backup::CreateBackupError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        "TableInUseException" => crate::operation::create_backup::CreateBackupError::TableInUseException({
   99     84   
            #[allow(unused_mut)]
  100     85   
            let mut tmp = {
  101     86   
                #[allow(unused_mut)]
  102     87   
                let mut output = crate::types::error::builders::TableInUseExceptionBuilder::default();
  103     88   
                output = crate::protocol_serde::shape_table_in_use_exception::de_table_in_use_exception_json_err(_response_body, output)
  104     89   
                    .map_err(crate::operation::create_backup::CreateBackupError::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   
        "TableNotFoundException" => crate::operation::create_backup::CreateBackupError::TableNotFoundException({
  114     96   
            #[allow(unused_mut)]
  115     97   
            let mut tmp = {
  116     98   
                #[allow(unused_mut)]
  117     99   
                let mut output = crate::types::error::builders::TableNotFoundExceptionBuilder::default();
  118    100   
                output = crate::protocol_serde::shape_table_not_found_exception::de_table_not_found_exception_json_err(_response_body, output)
  119    101   
                    .map_err(crate::operation::create_backup::CreateBackupError::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   
        _ => crate::operation::create_backup::CreateBackupError::generic(generic),
  129    108   
    })
  130    109   
}
  131    110   
  132    111   
#[allow(clippy::unnecessary_wraps)]
  133    112   
pub fn de_create_backup_http_response(
  134    113   
    _response_status: u16,
  135    114   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -4,4 +126,111 @@
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::GlobalTableAlreadyExistsExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_global_table_already_exists_exception::de_global_table_already_exists_exception_json_err(
   27     27   
                    _response_body,
   28     28   
                    output,
   29     29   
                )
   30     30   
                .map_err(crate::operation::create_global_table::CreateGlobalTableError::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::create_global_table::CreateGlobalTableError::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::create_global_table::CreateGlobalTableError::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::create_global_table::CreateGlobalTableError::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::create_global_table::CreateGlobalTableError::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   
        "LimitExceededException" => crate::operation::create_global_table::CreateGlobalTableError::LimitExceededException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;
   76     67   
                let output = output.meta(generic);
   77     68   
                output.build()
   78     69   
            };
   79         -
            if tmp.message.is_none() {
   80         -
                tmp.message = _error_message;
   81         -
            }
   82     70   
            tmp
   83     71   
        }),
   84     72   
        "TableNotFoundException" => crate::operation::create_global_table::CreateGlobalTableError::TableNotFoundException({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::TableNotFoundExceptionBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_table_not_found_exception::de_table_not_found_exception_json_err(_response_body, output)
   90     78   
                    .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;
   91     79   
                let output = output.meta(generic);
   92     80   
                output.build()
   93     81   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     82   
            tmp
   98     83   
        }),
   99     84   
        _ => crate::operation::create_global_table::CreateGlobalTableError::generic(generic),
  100     85   
    })
  101     86   
}
  102     87   
  103     88   
#[allow(clippy::unnecessary_wraps)]
  104     89   
pub fn de_create_global_table_http_response(
  105     90   
    _response_status: u16,
  106     91   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +107,95 @@
   20     20   
        "InternalServerError" => crate::operation::create_table::CreateTableError::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::create_table::CreateTableError::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::create_table::CreateTableError::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::create_table::CreateTableError::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::create_table::CreateTableError::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::create_table::CreateTableError::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::create_table::CreateTableError::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::create_table::CreateTableError::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   
        _ => crate::operation::create_table::CreateTableError::generic(generic),
   81     69   
    })
   82     70   
}
   83     71   
   84     72   
#[allow(clippy::unnecessary_wraps)]
   85     73   
pub fn de_create_table_http_response(
   86     74   
    _response_status: u16,
   87     75   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,