AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df (ignoring whitespace)

Files changed:

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

@@ -1,1 +78,72 @@
   21     21   
        "ResourceNotFoundException" => crate::operation::delete_stored_query::DeleteStoredQueryError::ResourceNotFoundException({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::delete_stored_query::DeleteStoredQueryError::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   
        "ValidationException" => crate::operation::delete_stored_query::DeleteStoredQueryError::ValidationException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::delete_stored_query::DeleteStoredQueryError::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   
        _ => crate::operation::delete_stored_query::DeleteStoredQueryError::generic(generic),
   52     46   
    })
   53     47   
}
   54     48   
   55     49   
#[allow(clippy::unnecessary_wraps)]
   56     50   
pub fn de_delete_stored_query_http_response(
   57     51   
    _response_status: u16,
   58     52   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +100,91 @@
   23     23   
        "NoAvailableConfigurationRecorderException" => {
   24     24   
            crate::operation::deliver_config_snapshot::DeliverConfigSnapshotError::NoAvailableConfigurationRecorderException({
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::NoAvailableConfigurationRecorderExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_no_available_configuration_recorder_exception::de_no_available_configuration_recorder_exception_json_err(_response_body, output).map_err(crate::operation::deliver_config_snapshot::DeliverConfigSnapshotError::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   
        }
   39     36   
        "NoRunningConfigurationRecorderException" => {
   40     37   
            crate::operation::deliver_config_snapshot::DeliverConfigSnapshotError::NoRunningConfigurationRecorderException({
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut tmp = {
   43     40   
                    #[allow(unused_mut)]
   44     41   
                    let mut output = crate::types::error::builders::NoRunningConfigurationRecorderExceptionBuilder::default();
   45     42   
                    output = crate::protocol_serde::shape_no_running_configuration_recorder_exception::de_no_running_configuration_recorder_exception_json_err(_response_body, output).map_err(crate::operation::deliver_config_snapshot::DeliverConfigSnapshotError::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   
        }
   55     49   
        "NoSuchDeliveryChannelException" => crate::operation::deliver_config_snapshot::DeliverConfigSnapshotError::NoSuchDeliveryChannelException({
   56     50   
            #[allow(unused_mut)]
   57     51   
            let mut tmp = {
   58     52   
                #[allow(unused_mut)]
   59     53   
                let mut output = crate::types::error::builders::NoSuchDeliveryChannelExceptionBuilder::default();
   60     54   
                output = crate::protocol_serde::shape_no_such_delivery_channel_exception::de_no_such_delivery_channel_exception_json_err(
   61     55   
                    _response_body,
   62     56   
                    output,
   63     57   
                )
   64     58   
                .map_err(crate::operation::deliver_config_snapshot::DeliverConfigSnapshotError::unhandled)?;
   65     59   
                let output = output.meta(generic);
   66     60   
                output.build()
   67     61   
            };
   68         -
            if tmp.message.is_none() {
   69         -
                tmp.message = _error_message;
   70         -
            }
   71     62   
            tmp
   72     63   
        }),
   73     64   
        _ => crate::operation::deliver_config_snapshot::DeliverConfigSnapshotError::generic(generic),
   74     65   
    })
   75     66   
}
   76     67   
   77     68   
#[allow(clippy::unnecessary_wraps)]
   78     69   
pub fn de_deliver_config_snapshot_http_response(
   79     70   
    _response_status: u16,
   80     71   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -8,8 +118,106 @@
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp =
   30     30   
                 {
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidLimitExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_limit_exception::de_invalid_limit_exception_json_err(_response_body, output).map_err(crate::operation::describe_aggregate_compliance_by_config_rules::DescribeAggregateComplianceByConfigRulesError::unhandled)?;
   34     34   
                    let output = output.meta(generic);
   35     35   
                    output.build()
   36     36   
                }
   37     37   
            ;
   38         -
            if tmp.message.is_none() {
   39         -
                                                            tmp.message = _error_message;
   40         -
                                                        }
   41     38   
            tmp
   42     39   
        }),
   43     40   
        "InvalidNextTokenException" => crate::operation::describe_aggregate_compliance_by_config_rules::DescribeAggregateComplianceByConfigRulesError::InvalidNextTokenException({
   44     41   
            #[allow(unused_mut)]
   45     42   
            let mut tmp =
   46     43   
                 {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   49     46   
                    output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output).map_err(crate::operation::describe_aggregate_compliance_by_config_rules::DescribeAggregateComplianceByConfigRulesError::unhandled)?;
   50     47   
                    let output = output.meta(generic);
   51     48   
                    output.build()
   52     49   
                }
   53     50   
            ;
   54         -
            if tmp.message.is_none() {
   55         -
                                                            tmp.message = _error_message;
   56         -
                                                        }
   57     51   
            tmp
   58     52   
        }),
   59     53   
        "NoSuchConfigurationAggregatorException" => crate::operation::describe_aggregate_compliance_by_config_rules::DescribeAggregateComplianceByConfigRulesError::NoSuchConfigurationAggregatorException({
   60     54   
            #[allow(unused_mut)]
   61     55   
            let mut tmp =
   62     56   
                 {
   63     57   
                    #[allow(unused_mut)]
   64     58   
                    let mut output = crate::types::error::builders::NoSuchConfigurationAggregatorExceptionBuilder::default();
   65     59   
                    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::describe_aggregate_compliance_by_config_rules::DescribeAggregateComplianceByConfigRulesError::unhandled)?;
   66     60   
                    let output = output.meta(generic);
   67     61   
                    output.build()
   68     62   
                }
   69     63   
            ;
   70         -
            if tmp.message.is_none() {
   71         -
                                                            tmp.message = _error_message;
   72         -
                                                        }
   73     64   
            tmp
   74     65   
        }),
   75     66   
        "ValidationException" => crate::operation::describe_aggregate_compliance_by_config_rules::DescribeAggregateComplianceByConfigRulesError::ValidationException({
   76     67   
            #[allow(unused_mut)]
   77     68   
            let mut tmp =
   78     69   
                 {
   79     70   
                    #[allow(unused_mut)]
   80     71   
                    let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   81     72   
                    output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output).map_err(crate::operation::describe_aggregate_compliance_by_config_rules::DescribeAggregateComplianceByConfigRulesError::unhandled)?;
   82     73   
                    let output = output.meta(generic);
   83     74   
                    output.build()
   84     75   
                }
   85     76   
            ;
   86         -
            if tmp.message.is_none() {
   87         -
                                                            tmp.message = _error_message;
   88         -
                                                        }
   89     77   
            tmp
   90     78   
        }),
   91     79   
        _ => crate::operation::describe_aggregate_compliance_by_config_rules::DescribeAggregateComplianceByConfigRulesError::generic(generic)
   92     80   
    })
   93     81   
}
   94     82   
   95     83   
#[allow(clippy::unnecessary_wraps)]
   96     84   
pub fn de_describe_aggregate_compliance_by_config_rules_http_response(
   97     85   
    _response_status: u16,
   98     86   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -10,10 +120,108 @@
   30     30   
            #[allow(unused_mut)]
   31     31   
            let mut tmp =
   32     32   
                 {
   33     33   
                    #[allow(unused_mut)]
   34     34   
                    let mut output = crate::types::error::builders::InvalidLimitExceptionBuilder::default();
   35     35   
                    output = crate::protocol_serde::shape_invalid_limit_exception::de_invalid_limit_exception_json_err(_response_body, output).map_err(crate::operation::describe_aggregate_compliance_by_conformance_packs::DescribeAggregateComplianceByConformancePacksError::unhandled)?;
   36     36   
                    let output = output.meta(generic);
   37     37   
                    output.build()
   38     38   
                }
   39     39   
            ;
   40         -
            if tmp.message.is_none() {
   41         -
                                                            tmp.message = _error_message;
   42         -
                                                        }
   43     40   
            tmp
   44     41   
        }),
   45     42   
        "InvalidNextTokenException" => crate::operation::describe_aggregate_compliance_by_conformance_packs::DescribeAggregateComplianceByConformancePacksError::InvalidNextTokenException({
   46     43   
            #[allow(unused_mut)]
   47     44   
            let mut tmp =
   48     45   
                 {
   49     46   
                    #[allow(unused_mut)]
   50     47   
                    let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   51     48   
                    output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output).map_err(crate::operation::describe_aggregate_compliance_by_conformance_packs::DescribeAggregateComplianceByConformancePacksError::unhandled)?;
   52     49   
                    let output = output.meta(generic);
   53     50   
                    output.build()
   54     51   
                }
   55     52   
            ;
   56         -
            if tmp.message.is_none() {
   57         -
                                                            tmp.message = _error_message;
   58         -
                                                        }
   59     53   
            tmp
   60     54   
        }),
   61     55   
        "NoSuchConfigurationAggregatorException" => crate::operation::describe_aggregate_compliance_by_conformance_packs::DescribeAggregateComplianceByConformancePacksError::NoSuchConfigurationAggregatorException({
   62     56   
            #[allow(unused_mut)]
   63     57   
            let mut tmp =
   64     58   
                 {
   65     59   
                    #[allow(unused_mut)]
   66     60   
                    let mut output = crate::types::error::builders::NoSuchConfigurationAggregatorExceptionBuilder::default();
   67     61   
                    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::describe_aggregate_compliance_by_conformance_packs::DescribeAggregateComplianceByConformancePacksError::unhandled)?;
   68     62   
                    let output = output.meta(generic);
   69     63   
                    output.build()
   70     64   
                }
   71     65   
            ;
   72         -
            if tmp.message.is_none() {
   73         -
                                                            tmp.message = _error_message;
   74         -
                                                        }
   75     66   
            tmp
   76     67   
        }),
   77     68   
        "ValidationException" => crate::operation::describe_aggregate_compliance_by_conformance_packs::DescribeAggregateComplianceByConformancePacksError::ValidationException({
   78     69   
            #[allow(unused_mut)]
   79     70   
            let mut tmp =
   80     71   
                 {
   81     72   
                    #[allow(unused_mut)]
   82     73   
                    let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   83     74   
                    output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output).map_err(crate::operation::describe_aggregate_compliance_by_conformance_packs::DescribeAggregateComplianceByConformancePacksError::unhandled)?;
   84     75   
                    let output = output.meta(generic);
   85     76   
                    output.build()
   86     77   
                }
   87     78   
            ;
   88         -
            if tmp.message.is_none() {
   89         -
                                                            tmp.message = _error_message;
   90         -
                                                        }
   91     79   
            tmp
   92     80   
        }),
   93     81   
        _ => crate::operation::describe_aggregate_compliance_by_conformance_packs::DescribeAggregateComplianceByConformancePacksError::generic(generic)
   94     82   
    })
   95     83   
}
   96     84   
   97     85   
#[allow(clippy::unnecessary_wraps)]
   98     86   
pub fn de_describe_aggregate_compliance_by_conformance_packs_http_response(
   99     87   
    _response_status: u16,
  100     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -4,4 +104,95 @@
   24     24   
            crate::operation::describe_aggregation_authorizations::DescribeAggregationAuthorizationsError::InvalidLimitException({
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidLimitExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_invalid_limit_exception::de_invalid_limit_exception_json_err(_response_body, output)
   30     30   
                        .map_err(crate::operation::describe_aggregation_authorizations::DescribeAggregationAuthorizationsError::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   
        "InvalidNextTokenException" => {
   41     38   
            crate::operation::describe_aggregation_authorizations::DescribeAggregationAuthorizationsError::InvalidNextTokenException({
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut tmp = {
   44     41   
                    #[allow(unused_mut)]
   45     42   
                    let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   46     43   
                    output =
   47     44   
                        crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   48     45   
                            .map_err(crate::operation::describe_aggregation_authorizations::DescribeAggregationAuthorizationsError::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   
        }
   58     52   
        "InvalidParameterValueException" => {
   59     53   
            crate::operation::describe_aggregation_authorizations::DescribeAggregationAuthorizationsError::InvalidParameterValueException({
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut tmp = {
   62     56   
                    #[allow(unused_mut)]
   63     57   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   64     58   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   65     59   
                        _response_body,
   66     60   
                        output,
   67     61   
                    )
   68     62   
                    .map_err(crate::operation::describe_aggregation_authorizations::DescribeAggregationAuthorizationsError::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   
        }
   78     69   
        _ => crate::operation::describe_aggregation_authorizations::DescribeAggregationAuthorizationsError::generic(generic),
   79     70   
    })
   80     71   
}
   81     72   
   82     73   
#[allow(clippy::unnecessary_wraps)]
   83     74   
pub fn de_describe_aggregation_authorizations_http_response(
   84     75   
    _response_status: u16,

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

@@ -5,5 +105,96 @@
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   29     29   
                    output =
   30     30   
                        crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   31     31   
                            .map_err(crate::operation::describe_compliance_by_config_rule::DescribeComplianceByConfigRuleError::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   
        "InvalidParameterValueException" => {
   42     39   
            crate::operation::describe_compliance_by_config_rule::DescribeComplianceByConfigRuleError::InvalidParameterValueException({
   43     40   
                #[allow(unused_mut)]
   44     41   
                let mut tmp = {
   45     42   
                    #[allow(unused_mut)]
   46     43   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   47     44   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   48     45   
                        _response_body,
   49     46   
                        output,
   50     47   
                    )
   51     48   
                    .map_err(crate::operation::describe_compliance_by_config_rule::DescribeComplianceByConfigRuleError::unhandled)?;
   52     49   
                    let output = output.meta(generic);
   53     50   
                    output.build()
   54     51   
                };
   55         -
                if tmp.message.is_none() {
   56         -
                    tmp.message = _error_message;
   57         -
                }
   58     52   
                tmp
   59     53   
            })
   60     54   
        }
   61     55   
        "NoSuchConfigRuleException" => {
   62     56   
            crate::operation::describe_compliance_by_config_rule::DescribeComplianceByConfigRuleError::NoSuchConfigRuleException({
   63     57   
                #[allow(unused_mut)]
   64     58   
                let mut tmp = {
   65     59   
                    #[allow(unused_mut)]
   66     60   
                    let mut output = crate::types::error::builders::NoSuchConfigRuleExceptionBuilder::default();
   67     61   
                    output =
   68     62   
                        crate::protocol_serde::shape_no_such_config_rule_exception::de_no_such_config_rule_exception_json_err(_response_body, output)
   69     63   
                            .map_err(crate::operation::describe_compliance_by_config_rule::DescribeComplianceByConfigRuleError::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   
        }
   79     70   
        _ => crate::operation::describe_compliance_by_config_rule::DescribeComplianceByConfigRuleError::generic(generic),
   80     71   
    })
   81     72   
}
   82     73   
   83     74   
#[allow(clippy::unnecessary_wraps)]
   84     75   
pub fn de_describe_compliance_by_config_rule_http_response(
   85     76   
    _response_status: u16,

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

@@ -5,5 +87,81 @@
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   29     29   
                    output =
   30     30   
                        crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   31     31   
                            .map_err(crate::operation::describe_compliance_by_resource::DescribeComplianceByResourceError::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   
        "InvalidParameterValueException" => {
   42     39   
            crate::operation::describe_compliance_by_resource::DescribeComplianceByResourceError::InvalidParameterValueException({
   43     40   
                #[allow(unused_mut)]
   44     41   
                let mut tmp = {
   45     42   
                    #[allow(unused_mut)]
   46     43   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   47     44   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   48     45   
                        _response_body,
   49     46   
                        output,
   50     47   
                    )
   51     48   
                    .map_err(crate::operation::describe_compliance_by_resource::DescribeComplianceByResourceError::unhandled)?;
   52     49   
                    let output = output.meta(generic);
   53     50   
                    output.build()
   54     51   
                };
   55         -
                if tmp.message.is_none() {
   56         -
                    tmp.message = _error_message;
   57         -
                }
   58     52   
                tmp
   59     53   
            })
   60     54   
        }
   61     55   
        _ => crate::operation::describe_compliance_by_resource::DescribeComplianceByResourceError::generic(generic),
   62     56   
    })
   63     57   
}
   64     58   
   65     59   
#[allow(clippy::unnecessary_wraps)]
   66     60   
pub fn de_describe_compliance_by_resource_http_response(
   67     61   
    _response_status: u16,

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

@@ -5,5 +105,96 @@
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   29     29   
                    output =
   30     30   
                        crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   31     31   
                            .map_err(crate::operation::describe_config_rule_evaluation_status::DescribeConfigRuleEvaluationStatusError::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   
        "InvalidParameterValueException" => {
   42     39   
            crate::operation::describe_config_rule_evaluation_status::DescribeConfigRuleEvaluationStatusError::InvalidParameterValueException({
   43     40   
                #[allow(unused_mut)]
   44     41   
                let mut tmp = {
   45     42   
                    #[allow(unused_mut)]
   46     43   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   47     44   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   48     45   
                        _response_body,
   49     46   
                        output,
   50     47   
                    )
   51     48   
                    .map_err(crate::operation::describe_config_rule_evaluation_status::DescribeConfigRuleEvaluationStatusError::unhandled)?;
   52     49   
                    let output = output.meta(generic);
   53     50   
                    output.build()
   54     51   
                };
   55         -
                if tmp.message.is_none() {
   56         -
                    tmp.message = _error_message;
   57         -
                }
   58     52   
                tmp
   59     53   
            })
   60     54   
        }
   61     55   
        "NoSuchConfigRuleException" => {
   62     56   
            crate::operation::describe_config_rule_evaluation_status::DescribeConfigRuleEvaluationStatusError::NoSuchConfigRuleException({
   63     57   
                #[allow(unused_mut)]
   64     58   
                let mut tmp = {
   65     59   
                    #[allow(unused_mut)]
   66     60   
                    let mut output = crate::types::error::builders::NoSuchConfigRuleExceptionBuilder::default();
   67     61   
                    output =
   68     62   
                        crate::protocol_serde::shape_no_such_config_rule_exception::de_no_such_config_rule_exception_json_err(_response_body, output)
   69     63   
                            .map_err(crate::operation::describe_config_rule_evaluation_status::DescribeConfigRuleEvaluationStatusError::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   
        }
   79     70   
        _ => crate::operation::describe_config_rule_evaluation_status::DescribeConfigRuleEvaluationStatusError::generic(generic),
   80     71   
    })
   81     72   
}
   82     73   
   83     74   
#[allow(clippy::unnecessary_wraps)]
   84     75   
pub fn de_describe_config_rule_evaluation_status_http_response(
   85     76   
    _response_status: u16,

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

@@ -3,3 +99,90 @@
   23     23   
        "InvalidNextTokenException" => crate::operation::describe_config_rules::DescribeConfigRulesError::InvalidNextTokenException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::describe_config_rules::DescribeConfigRulesError::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   
        "InvalidParameterValueException" => crate::operation::describe_config_rules::DescribeConfigRulesError::InvalidParameterValueException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   44     41   
                    _response_body,
   45     42   
                    output,
   46     43   
                )
   47     44   
                .map_err(crate::operation::describe_config_rules::DescribeConfigRulesError::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   
        "NoSuchConfigRuleException" => crate::operation::describe_config_rules::DescribeConfigRulesError::NoSuchConfigRuleException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::NoSuchConfigRuleExceptionBuilder::default();
   61     55   
                output =
   62     56   
                    crate::protocol_serde::shape_no_such_config_rule_exception::de_no_such_config_rule_exception_json_err(_response_body, output)
   63     57   
                        .map_err(crate::operation::describe_config_rules::DescribeConfigRulesError::unhandled)?;
   64     58   
                let output = output.meta(generic);
   65     59   
                output.build()
   66     60   
            };
   67         -
            if tmp.message.is_none() {
   68         -
                tmp.message = _error_message;
   69         -
            }
   70     61   
            tmp
   71     62   
        }),
   72     63   
        _ => crate::operation::describe_config_rules::DescribeConfigRulesError::generic(generic),
   73     64   
    })
   74     65   
}
   75     66   
   76     67   
#[allow(clippy::unnecessary_wraps)]
   77     68   
pub fn de_describe_config_rules_http_response(
   78     69   
    _response_status: u16,
   79     70   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -10,10 +120,108 @@
   30     30   
            #[allow(unused_mut)]
   31     31   
            let mut tmp =
   32     32   
                 {
   33     33   
                    #[allow(unused_mut)]
   34     34   
                    let mut output = crate::types::error::builders::InvalidLimitExceptionBuilder::default();
   35     35   
                    output = crate::protocol_serde::shape_invalid_limit_exception::de_invalid_limit_exception_json_err(_response_body, output).map_err(crate::operation::describe_configuration_aggregator_sources_status::DescribeConfigurationAggregatorSourcesStatusError::unhandled)?;
   36     36   
                    let output = output.meta(generic);
   37     37   
                    output.build()
   38     38   
                }
   39     39   
            ;
   40         -
            if tmp.message.is_none() {
   41         -
                                                            tmp.message = _error_message;
   42         -
                                                        }
   43     40   
            tmp
   44     41   
        }),
   45     42   
        "InvalidNextTokenException" => crate::operation::describe_configuration_aggregator_sources_status::DescribeConfigurationAggregatorSourcesStatusError::InvalidNextTokenException({
   46     43   
            #[allow(unused_mut)]
   47     44   
            let mut tmp =
   48     45   
                 {
   49     46   
                    #[allow(unused_mut)]
   50     47   
                    let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   51     48   
                    output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output).map_err(crate::operation::describe_configuration_aggregator_sources_status::DescribeConfigurationAggregatorSourcesStatusError::unhandled)?;
   52     49   
                    let output = output.meta(generic);
   53     50   
                    output.build()
   54     51   
                }
   55     52   
            ;
   56         -
            if tmp.message.is_none() {
   57         -
                                                            tmp.message = _error_message;
   58         -
                                                        }
   59     53   
            tmp
   60     54   
        }),
   61     55   
        "InvalidParameterValueException" => crate::operation::describe_configuration_aggregator_sources_status::DescribeConfigurationAggregatorSourcesStatusError::InvalidParameterValueException({
   62     56   
            #[allow(unused_mut)]
   63     57   
            let mut tmp =
   64     58   
                 {
   65     59   
                    #[allow(unused_mut)]
   66     60   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   67     61   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(_response_body, output).map_err(crate::operation::describe_configuration_aggregator_sources_status::DescribeConfigurationAggregatorSourcesStatusError::unhandled)?;
   68     62   
                    let output = output.meta(generic);
   69     63   
                    output.build()
   70     64   
                }
   71     65   
            ;
   72         -
            if tmp.message.is_none() {
   73         -
                                                            tmp.message = _error_message;
   74         -
                                                        }
   75     66   
            tmp
   76     67   
        }),
   77     68   
        "NoSuchConfigurationAggregatorException" => crate::operation::describe_configuration_aggregator_sources_status::DescribeConfigurationAggregatorSourcesStatusError::NoSuchConfigurationAggregatorException({
   78     69   
            #[allow(unused_mut)]
   79     70   
            let mut tmp =
   80     71   
                 {
   81     72   
                    #[allow(unused_mut)]
   82     73   
                    let mut output = crate::types::error::builders::NoSuchConfigurationAggregatorExceptionBuilder::default();
   83     74   
                    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::describe_configuration_aggregator_sources_status::DescribeConfigurationAggregatorSourcesStatusError::unhandled)?;
   84     75   
                    let output = output.meta(generic);
   85     76   
                    output.build()
   86     77   
                }
   87     78   
            ;
   88         -
            if tmp.message.is_none() {
   89         -
                                                            tmp.message = _error_message;
   90         -
                                                        }
   91     79   
            tmp
   92     80   
        }),
   93     81   
        _ => crate::operation::describe_configuration_aggregator_sources_status::DescribeConfigurationAggregatorSourcesStatusError::generic(generic)
   94     82   
    })
   95     83   
}
   96     84   
   97     85   
#[allow(clippy::unnecessary_wraps)]
   98     86   
pub fn de_describe_configuration_aggregator_sources_status_http_response(
   99     87   
    _response_status: u16,
  100     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -4,4 +120,108 @@
   24     24   
            crate::operation::describe_configuration_aggregators::DescribeConfigurationAggregatorsError::InvalidLimitException({
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidLimitExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_invalid_limit_exception::de_invalid_limit_exception_json_err(_response_body, output)
   30     30   
                        .map_err(crate::operation::describe_configuration_aggregators::DescribeConfigurationAggregatorsError::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   
        "InvalidNextTokenException" => {
   41     38   
            crate::operation::describe_configuration_aggregators::DescribeConfigurationAggregatorsError::InvalidNextTokenException({
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut tmp = {
   44     41   
                    #[allow(unused_mut)]
   45     42   
                    let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   46     43   
                    output =
   47     44   
                        crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   48     45   
                            .map_err(crate::operation::describe_configuration_aggregators::DescribeConfigurationAggregatorsError::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   
        }
   58     52   
        "InvalidParameterValueException" => {
   59     53   
            crate::operation::describe_configuration_aggregators::DescribeConfigurationAggregatorsError::InvalidParameterValueException({
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut tmp = {
   62     56   
                    #[allow(unused_mut)]
   63     57   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   64     58   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   65     59   
                        _response_body,
   66     60   
                        output,
   67     61   
                    )
   68     62   
                    .map_err(crate::operation::describe_configuration_aggregators::DescribeConfigurationAggregatorsError::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   
        }
   78     69   
        "NoSuchConfigurationAggregatorException" => {
   79     70   
            crate::operation::describe_configuration_aggregators::DescribeConfigurationAggregatorsError::NoSuchConfigurationAggregatorException({
   80     71   
                #[allow(unused_mut)]
   81     72   
                let mut tmp = {
   82     73   
                    #[allow(unused_mut)]
   83     74   
                    let mut output = crate::types::error::builders::NoSuchConfigurationAggregatorExceptionBuilder::default();
   84     75   
                    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::describe_configuration_aggregators::DescribeConfigurationAggregatorsError::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   
        }
   94     82   
        _ => crate::operation::describe_configuration_aggregators::DescribeConfigurationAggregatorsError::generic(generic),
   95     83   
    })
   96     84   
}
   97     85   
   98     86   
#[allow(clippy::unnecessary_wraps)]
   99     87   
pub fn de_describe_configuration_aggregators_http_response(
  100     88   
    _response_status: u16,

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

@@ -4,4 +66,63 @@
   24     24   
            crate::operation::describe_configuration_recorder_status::DescribeConfigurationRecorderStatusError::NoSuchConfigurationRecorderException(
   25     25   
                {
   26     26   
                    #[allow(unused_mut)]
   27     27   
                    let mut tmp = {
   28     28   
                        #[allow(unused_mut)]
   29     29   
                        let mut output = crate::types::error::builders::NoSuchConfigurationRecorderExceptionBuilder::default();
   30     30   
                        output = crate::protocol_serde::shape_no_such_configuration_recorder_exception::de_no_such_configuration_recorder_exception_json_err(_response_body, output).map_err(crate::operation::describe_configuration_recorder_status::DescribeConfigurationRecorderStatusError::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   
        }
   41     38   
        _ => crate::operation::describe_configuration_recorder_status::DescribeConfigurationRecorderStatusError::generic(generic),
   42     39   
    })
   43     40   
}
   44     41   
   45     42   
#[allow(clippy::unnecessary_wraps)]
   46     43   
pub fn de_describe_configuration_recorder_status_http_response(

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

@@ -8,8 +70,67 @@
   28     28   
                    let mut output = crate::types::error::builders::NoSuchConfigurationRecorderExceptionBuilder::default();
   29     29   
                    output =
   30     30   
                        crate::protocol_serde::shape_no_such_configuration_recorder_exception::de_no_such_configuration_recorder_exception_json_err(
   31     31   
                            _response_body,
   32     32   
                            output,
   33     33   
                        )
   34     34   
                        .map_err(crate::operation::describe_configuration_recorders::DescribeConfigurationRecordersError::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   
        _ => crate::operation::describe_configuration_recorders::DescribeConfigurationRecordersError::generic(generic),
   45     42   
    })
   46     43   
}
   47     44   
   48     45   
#[allow(clippy::unnecessary_wraps)]
   49     46   
pub fn de_describe_configuration_recorders_http_response(
   50     47   
    _response_status: u16,

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

@@ -4,4 +142,127 @@
   24     24   
            crate::operation::describe_conformance_pack_compliance::DescribeConformancePackComplianceError::InvalidLimitException({
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidLimitExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_invalid_limit_exception::de_invalid_limit_exception_json_err(_response_body, output)
   30     30   
                        .map_err(crate::operation::describe_conformance_pack_compliance::DescribeConformancePackComplianceError::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   
        "InvalidNextTokenException" => {
   41     38   
            crate::operation::describe_conformance_pack_compliance::DescribeConformancePackComplianceError::InvalidNextTokenException({
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut tmp = {
   44     41   
                    #[allow(unused_mut)]
   45     42   
                    let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   46     43   
                    output =
   47     44   
                        crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   48     45   
                            .map_err(crate::operation::describe_conformance_pack_compliance::DescribeConformancePackComplianceError::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   
        }
   58     52   
        "InvalidParameterValueException" => {
   59     53   
            crate::operation::describe_conformance_pack_compliance::DescribeConformancePackComplianceError::InvalidParameterValueException({
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut tmp = {
   62     56   
                    #[allow(unused_mut)]
   63     57   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   64     58   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   65     59   
                        _response_body,
   66     60   
                        output,
   67     61   
                    )
   68     62   
                    .map_err(crate::operation::describe_conformance_pack_compliance::DescribeConformancePackComplianceError::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   
        }
   78     69   
        "NoSuchConfigRuleInConformancePackException" => {
   79     70   
            crate::operation::describe_conformance_pack_compliance::DescribeConformancePackComplianceError::NoSuchConfigRuleInConformancePackException(
   80     71   
                {
   81     72   
                    #[allow(unused_mut)]
   82     73   
                    let mut tmp = {
   83     74   
                        #[allow(unused_mut)]
   84     75   
                        let mut output = crate::types::error::builders::NoSuchConfigRuleInConformancePackExceptionBuilder::default();
   85     76   
                        output = crate::protocol_serde::shape_no_such_config_rule_in_conformance_pack_exception::de_no_such_config_rule_in_conformance_pack_exception_json_err(_response_body, output).map_err(crate::operation::describe_conformance_pack_compliance::DescribeConformancePackComplianceError::unhandled)?;
   86     77   
                        let output = output.meta(generic);
   87     78   
                        output.build()
   88     79   
                    };
   89         -
                    if tmp.message.is_none() {
   90         -
                        tmp.message = _error_message;
   91         -
                    }
   92     80   
                    tmp
   93     81   
                },
   94     82   
            )
   95     83   
        }
   96     84   
        "NoSuchConformancePackException" => {
   97     85   
            crate::operation::describe_conformance_pack_compliance::DescribeConformancePackComplianceError::NoSuchConformancePackException({
   98     86   
                #[allow(unused_mut)]
   99     87   
                let mut tmp = {
  100     88   
                    #[allow(unused_mut)]
  101     89   
                    let mut output = crate::types::error::builders::NoSuchConformancePackExceptionBuilder::default();
  102     90   
                    output = crate::protocol_serde::shape_no_such_conformance_pack_exception::de_no_such_conformance_pack_exception_json_err(
  103     91   
                        _response_body,
  104     92   
                        output,
  105     93   
                    )
  106     94   
                    .map_err(crate::operation::describe_conformance_pack_compliance::DescribeConformancePackComplianceError::unhandled)?;
  107     95   
                    let output = output.meta(generic);
  108     96   
                    output.build()
  109     97   
                };
  110         -
                if tmp.message.is_none() {
  111         -
                    tmp.message = _error_message;
  112         -
                }
  113     98   
                tmp
  114     99   
            })
  115    100   
        }
  116    101   
        _ => crate::operation::describe_conformance_pack_compliance::DescribeConformancePackComplianceError::generic(generic),
  117    102   
    })
  118    103   
}
  119    104   
  120    105   
#[allow(clippy::unnecessary_wraps)]
  121    106   
pub fn de_describe_conformance_pack_compliance_http_response(
  122    107   
    _response_status: u16,

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

@@ -3,3 +102,93 @@
   23     23   
        "InvalidLimitException" => crate::operation::describe_conformance_pack_status::DescribeConformancePackStatusError::InvalidLimitException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidLimitExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_limit_exception::de_invalid_limit_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::describe_conformance_pack_status::DescribeConformancePackStatusError::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   
        "InvalidNextTokenException" => {
   39     36   
            crate::operation::describe_conformance_pack_status::DescribeConformancePackStatusError::InvalidNextTokenException({
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut tmp = {
   42     39   
                    #[allow(unused_mut)]
   43     40   
                    let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   44     41   
                    output =
   45     42   
                        crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   46     43   
                            .map_err(crate::operation::describe_conformance_pack_status::DescribeConformancePackStatusError::unhandled)?;
   47     44   
                    let output = output.meta(generic);
   48     45   
                    output.build()
   49     46   
                };
   50         -
                if tmp.message.is_none() {
   51         -
                    tmp.message = _error_message;
   52         -
                }
   53     47   
                tmp
   54     48   
            })
   55     49   
        }
   56     50   
        "InvalidParameterValueException" => {
   57     51   
            crate::operation::describe_conformance_pack_status::DescribeConformancePackStatusError::InvalidParameterValueException({
   58     52   
                #[allow(unused_mut)]
   59     53   
                let mut tmp = {
   60     54   
                    #[allow(unused_mut)]
   61     55   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   62     56   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   63     57   
                        _response_body,
   64     58   
                        output,
   65     59   
                    )
   66     60   
                    .map_err(crate::operation::describe_conformance_pack_status::DescribeConformancePackStatusError::unhandled)?;
   67     61   
                    let output = output.meta(generic);
   68     62   
                    output.build()
   69     63   
                };
   70         -
                if tmp.message.is_none() {
   71         -
                    tmp.message = _error_message;
   72         -
                }
   73     64   
                tmp
   74     65   
            })
   75     66   
        }
   76     67   
        _ => crate::operation::describe_conformance_pack_status::DescribeConformancePackStatusError::generic(generic),
   77     68   
    })
   78     69   
}
   79     70   
   80     71   
#[allow(clippy::unnecessary_wraps)]
   81     72   
pub fn de_describe_conformance_pack_status_http_response(
   82     73   
    _response_status: u16,

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

@@ -7,7 +123,111 @@
   27     27   
        "InvalidLimitException" => crate::operation::describe_conformance_packs::DescribeConformancePacksError::InvalidLimitException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::InvalidLimitExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_invalid_limit_exception::de_invalid_limit_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::describe_conformance_packs::DescribeConformancePacksError::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   
        "InvalidNextTokenException" => crate::operation::describe_conformance_packs::DescribeConformancePacksError::InvalidNextTokenException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::describe_conformance_packs::DescribeConformancePacksError::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   
        "InvalidParameterValueException" => {
   58     52   
            crate::operation::describe_conformance_packs::DescribeConformancePacksError::InvalidParameterValueException({
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut tmp = {
   61     55   
                    #[allow(unused_mut)]
   62     56   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   63     57   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   64     58   
                        _response_body,
   65     59   
                        output,
   66     60   
                    )
   67     61   
                    .map_err(crate::operation::describe_conformance_packs::DescribeConformancePacksError::unhandled)?;
   68     62   
                    let output = output.meta(generic);
   69     63   
                    output.build()
   70     64   
                };
   71         -
                if tmp.message.is_none() {
   72         -
                    tmp.message = _error_message;
   73         -
                }
   74     65   
                tmp
   75     66   
            })
   76     67   
        }
   77     68   
        "NoSuchConformancePackException" => {
   78     69   
            crate::operation::describe_conformance_packs::DescribeConformancePacksError::NoSuchConformancePackException({
   79     70   
                #[allow(unused_mut)]
   80     71   
                let mut tmp = {
   81     72   
                    #[allow(unused_mut)]
   82     73   
                    let mut output = crate::types::error::builders::NoSuchConformancePackExceptionBuilder::default();
   83     74   
                    output = crate::protocol_serde::shape_no_such_conformance_pack_exception::de_no_such_conformance_pack_exception_json_err(
   84     75   
                        _response_body,
   85     76   
                        output,
   86     77   
                    )
   87     78   
                    .map_err(crate::operation::describe_conformance_packs::DescribeConformancePacksError::unhandled)?;
   88     79   
                    let output = output.meta(generic);
   89     80   
                    output.build()
   90     81   
                };
   91         -
                if tmp.message.is_none() {
   92         -
                    tmp.message = _error_message;
   93         -
                }
   94     82   
                tmp
   95     83   
            })
   96     84   
        }
   97     85   
        _ => crate::operation::describe_conformance_packs::DescribeConformancePacksError::generic(generic),
   98     86   
    })
   99     87   
}
  100     88   
  101     89   
#[allow(clippy::unnecessary_wraps)]
  102     90   
pub fn de_describe_conformance_packs_http_response(
  103     91   
    _response_status: u16,