AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df

Files changed:

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

@@ -7,7 +69,66 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::NoSuchDeliveryChannelExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_no_such_delivery_channel_exception::de_no_such_delivery_channel_exception_json_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::describe_delivery_channel_status::DescribeDeliveryChannelStatusError::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   
        _ => crate::operation::describe_delivery_channel_status::DescribeDeliveryChannelStatusError::generic(generic),
   44     41   
    })
   45     42   
}
   46     43   
   47     44   
#[allow(clippy::unnecessary_wraps)]
   48     45   
pub fn de_describe_delivery_channel_status_http_response(
   49     46   
    _response_status: u16,

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

@@ -11,11 +73,70 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::NoSuchDeliveryChannelExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_no_such_delivery_channel_exception::de_no_such_delivery_channel_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::describe_delivery_channels::DescribeDeliveryChannelsError::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   
        _ => crate::operation::describe_delivery_channels::DescribeDeliveryChannelsError::generic(generic),
   48     45   
    })
   49     46   
}
   50     47   
   51     48   
#[allow(clippy::unnecessary_wraps)]
   52     49   
pub fn de_describe_delivery_channels_http_response(
   53     50   
    _response_status: u16,

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

@@ -6,6 +116,104 @@
   26     26   
            #[allow(unused_mut)]
   27     27   
            let mut tmp =
   28     28   
                 {
   29     29   
                    #[allow(unused_mut)]
   30     30   
                    let mut output = crate::types::error::builders::InvalidLimitExceptionBuilder::default();
   31     31   
                    output = crate::protocol_serde::shape_invalid_limit_exception::de_invalid_limit_exception_json_err(_response_body, output).map_err(crate::operation::describe_organization_config_rule_statuses::DescribeOrganizationConfigRuleStatusesError::unhandled)?;
   32     32   
                    let output = output.meta(generic);
   33     33   
                    output.build()
   34     34   
                }
   35     35   
            ;
   36         -
            if tmp.message.is_none() {
   37         -
                                                            tmp.message = _error_message;
   38         -
                                                        }
   39     36   
            tmp
   40     37   
        }),
   41     38   
        "InvalidNextTokenException" => crate::operation::describe_organization_config_rule_statuses::DescribeOrganizationConfigRuleStatusesError::InvalidNextTokenException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp =
   44     41   
                 {
   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).map_err(crate::operation::describe_organization_config_rule_statuses::DescribeOrganizationConfigRuleStatusesError::unhandled)?;
   48     45   
                    let output = output.meta(generic);
   49     46   
                    output.build()
   50     47   
                }
   51     48   
            ;
   52         -
            if tmp.message.is_none() {
   53         -
                                                            tmp.message = _error_message;
   54         -
                                                        }
   55     49   
            tmp
   56     50   
        }),
   57     51   
        "NoSuchOrganizationConfigRuleException" => crate::operation::describe_organization_config_rule_statuses::DescribeOrganizationConfigRuleStatusesError::NoSuchOrganizationConfigRuleException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp =
   60     54   
                 {
   61     55   
                    #[allow(unused_mut)]
   62     56   
                    let mut output = crate::types::error::builders::NoSuchOrganizationConfigRuleExceptionBuilder::default();
   63     57   
                    output = crate::protocol_serde::shape_no_such_organization_config_rule_exception::de_no_such_organization_config_rule_exception_json_err(_response_body, output).map_err(crate::operation::describe_organization_config_rule_statuses::DescribeOrganizationConfigRuleStatusesError::unhandled)?;
   64     58   
                    let output = output.meta(generic);
   65     59   
                    output.build()
   66     60   
                }
   67     61   
            ;
   68         -
            if tmp.message.is_none() {
   69         -
                                                            tmp.message = _error_message;
   70         -
                                                        }
   71     62   
            tmp
   72     63   
        }),
   73     64   
        "OrganizationAccessDeniedException" => crate::operation::describe_organization_config_rule_statuses::DescribeOrganizationConfigRuleStatusesError::OrganizationAccessDeniedException({
   74     65   
            #[allow(unused_mut)]
   75     66   
            let mut tmp =
   76     67   
                 {
   77     68   
                    #[allow(unused_mut)]
   78     69   
                    let mut output = crate::types::error::builders::OrganizationAccessDeniedExceptionBuilder::default();
   79     70   
                    output = crate::protocol_serde::shape_organization_access_denied_exception::de_organization_access_denied_exception_json_err(_response_body, output).map_err(crate::operation::describe_organization_config_rule_statuses::DescribeOrganizationConfigRuleStatusesError::unhandled)?;
   80     71   
                    let output = output.meta(generic);
   81     72   
                    output.build()
   82     73   
                }
   83     74   
            ;
   84         -
            if tmp.message.is_none() {
   85         -
                                                            tmp.message = _error_message;
   86         -
                                                        }
   87     75   
            tmp
   88     76   
        }),
   89     77   
        _ => crate::operation::describe_organization_config_rule_statuses::DescribeOrganizationConfigRuleStatusesError::generic(generic)
   90     78   
    })
   91     79   
}
   92     80   
   93     81   
#[allow(clippy::unnecessary_wraps)]
   94     82   
pub fn de_describe_organization_config_rule_statuses_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_describe_organization_config_rules.rs

@@ -4,4 +120,108 @@
   24     24   
            crate::operation::describe_organization_config_rules::DescribeOrganizationConfigRulesError::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_organization_config_rules::DescribeOrganizationConfigRulesError::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_organization_config_rules::DescribeOrganizationConfigRulesError::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_organization_config_rules::DescribeOrganizationConfigRulesError::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   
        "NoSuchOrganizationConfigRuleException" => {
   59     53   
            crate::operation::describe_organization_config_rules::DescribeOrganizationConfigRulesError::NoSuchOrganizationConfigRuleException({
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut tmp = {
   62     56   
                    #[allow(unused_mut)]
   63     57   
                    let mut output = crate::types::error::builders::NoSuchOrganizationConfigRuleExceptionBuilder::default();
   64     58   
                    output = crate::protocol_serde::shape_no_such_organization_config_rule_exception::de_no_such_organization_config_rule_exception_json_err(_response_body, output).map_err(crate::operation::describe_organization_config_rules::DescribeOrganizationConfigRulesError::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   
        "OrganizationAccessDeniedException" => {
   75     66   
            crate::operation::describe_organization_config_rules::DescribeOrganizationConfigRulesError::OrganizationAccessDeniedException({
   76     67   
                #[allow(unused_mut)]
   77     68   
                let mut tmp = {
   78     69   
                    #[allow(unused_mut)]
   79     70   
                    let mut output = crate::types::error::builders::OrganizationAccessDeniedExceptionBuilder::default();
   80     71   
                    output = crate::protocol_serde::shape_organization_access_denied_exception::de_organization_access_denied_exception_json_err(
   81     72   
                        _response_body,
   82     73   
                        output,
   83     74   
                    )
   84     75   
                    .map_err(crate::operation::describe_organization_config_rules::DescribeOrganizationConfigRulesError::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_organization_config_rules::DescribeOrganizationConfigRulesError::generic(generic),
   95     83   
    })
   96     84   
}
   97     85   
   98     86   
#[allow(clippy::unnecessary_wraps)]
   99     87   
pub fn de_describe_organization_config_rules_http_response(
  100     88   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_describe_organization_conformance_pack_statuses.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_organization_conformance_pack_statuses::DescribeOrganizationConformancePackStatusesError::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_organization_conformance_pack_statuses::DescribeOrganizationConformancePackStatusesError::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_organization_conformance_pack_statuses::DescribeOrganizationConformancePackStatusesError::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   
        "NoSuchOrganizationConformancePackException" => crate::operation::describe_organization_conformance_pack_statuses::DescribeOrganizationConformancePackStatusesError::NoSuchOrganizationConformancePackException({
   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::NoSuchOrganizationConformancePackExceptionBuilder::default();
   67     61   
                    output = crate::protocol_serde::shape_no_such_organization_conformance_pack_exception::de_no_such_organization_conformance_pack_exception_json_err(_response_body, output).map_err(crate::operation::describe_organization_conformance_pack_statuses::DescribeOrganizationConformancePackStatusesError::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   
        "OrganizationAccessDeniedException" => crate::operation::describe_organization_conformance_pack_statuses::DescribeOrganizationConformancePackStatusesError::OrganizationAccessDeniedException({
   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::OrganizationAccessDeniedExceptionBuilder::default();
   83     74   
                    output = crate::protocol_serde::shape_organization_access_denied_exception::de_organization_access_denied_exception_json_err(_response_body, output).map_err(crate::operation::describe_organization_conformance_pack_statuses::DescribeOrganizationConformancePackStatusesError::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_organization_conformance_pack_statuses::DescribeOrganizationConformancePackStatusesError::generic(generic)
   94     82   
    })
   95     83   
}
   96     84   
   97     85   
#[allow(clippy::unnecessary_wraps)]
   98     86   
pub fn de_describe_organization_conformance_pack_statuses_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_organization_conformance_packs.rs

@@ -4,4 +114,102 @@
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp =
   26     26   
                 {
   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).map_err(crate::operation::describe_organization_conformance_packs::DescribeOrganizationConformancePacksError::unhandled)?;
   30     30   
                    let output = output.meta(generic);
   31     31   
                    output.build()
   32     32   
                }
   33     33   
            ;
   34         -
            if tmp.message.is_none() {
   35         -
                                                            tmp.message = _error_message;
   36         -
                                                        }
   37     34   
            tmp
   38     35   
        }),
   39     36   
        "InvalidNextTokenException" => crate::operation::describe_organization_conformance_packs::DescribeOrganizationConformancePacksError::InvalidNextTokenException({
   40     37   
            #[allow(unused_mut)]
   41     38   
            let mut tmp =
   42     39   
                 {
   43     40   
                    #[allow(unused_mut)]
   44     41   
                    let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   45     42   
                    output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output).map_err(crate::operation::describe_organization_conformance_packs::DescribeOrganizationConformancePacksError::unhandled)?;
   46     43   
                    let output = output.meta(generic);
   47     44   
                    output.build()
   48     45   
                }
   49     46   
            ;
   50         -
            if tmp.message.is_none() {
   51         -
                                                            tmp.message = _error_message;
   52         -
                                                        }
   53     47   
            tmp
   54     48   
        }),
   55     49   
        "NoSuchOrganizationConformancePackException" => crate::operation::describe_organization_conformance_packs::DescribeOrganizationConformancePacksError::NoSuchOrganizationConformancePackException({
   56     50   
            #[allow(unused_mut)]
   57     51   
            let mut tmp =
   58     52   
                 {
   59     53   
                    #[allow(unused_mut)]
   60     54   
                    let mut output = crate::types::error::builders::NoSuchOrganizationConformancePackExceptionBuilder::default();
   61     55   
                    output = crate::protocol_serde::shape_no_such_organization_conformance_pack_exception::de_no_such_organization_conformance_pack_exception_json_err(_response_body, output).map_err(crate::operation::describe_organization_conformance_packs::DescribeOrganizationConformancePacksError::unhandled)?;
   62     56   
                    let output = output.meta(generic);
   63     57   
                    output.build()
   64     58   
                }
   65     59   
            ;
   66         -
            if tmp.message.is_none() {
   67         -
                                                            tmp.message = _error_message;
   68         -
                                                        }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "OrganizationAccessDeniedException" => crate::operation::describe_organization_conformance_packs::DescribeOrganizationConformancePacksError::OrganizationAccessDeniedException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp =
   74     65   
                 {
   75     66   
                    #[allow(unused_mut)]
   76     67   
                    let mut output = crate::types::error::builders::OrganizationAccessDeniedExceptionBuilder::default();
   77     68   
                    output = crate::protocol_serde::shape_organization_access_denied_exception::de_organization_access_denied_exception_json_err(_response_body, output).map_err(crate::operation::describe_organization_conformance_packs::DescribeOrganizationConformancePacksError::unhandled)?;
   78     69   
                    let output = output.meta(generic);
   79     70   
                    output.build()
   80     71   
                }
   81     72   
            ;
   82         -
            if tmp.message.is_none() {
   83         -
                                                            tmp.message = _error_message;
   84         -
                                                        }
   85     73   
            tmp
   86     74   
        }),
   87     75   
        _ => crate::operation::describe_organization_conformance_packs::DescribeOrganizationConformancePacksError::generic(generic)
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_describe_organization_conformance_packs_http_response(
   93     81   
    _response_status: u16,
   94     82   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -4,4 +104,95 @@
   24     24   
            crate::operation::describe_pending_aggregation_requests::DescribePendingAggregationRequestsError::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_pending_aggregation_requests::DescribePendingAggregationRequestsError::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_pending_aggregation_requests::DescribePendingAggregationRequestsError::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_pending_aggregation_requests::DescribePendingAggregationRequestsError::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_pending_aggregation_requests::DescribePendingAggregationRequestsError::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_pending_aggregation_requests::DescribePendingAggregationRequestsError::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_pending_aggregation_requests::DescribePendingAggregationRequestsError::generic(generic),
   79     70   
    })
   80     71   
}
   81     72   
   82     73   
#[allow(clippy::unnecessary_wraps)]
   83     74   
pub fn de_describe_pending_aggregation_requests_http_response(
   84     75   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_describe_remediation_exceptions.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_remediation_exceptions::DescribeRemediationExceptionsError::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_remediation_exceptions::DescribeRemediationExceptionsError::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_remediation_exceptions::DescribeRemediationExceptionsError::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_remediation_exceptions::DescribeRemediationExceptionsError::generic(generic),
   62     56   
    })
   63     57   
}
   64     58   
   65     59   
#[allow(clippy::unnecessary_wraps)]
   66     60   
pub fn de_describe_remediation_exceptions_http_response(
   67     61   
    _response_status: u16,

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

@@ -5,5 +104,95 @@
   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_remediation_execution_status::DescribeRemediationExecutionStatusError::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_remediation_execution_status::DescribeRemediationExecutionStatusError::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_remediation_execution_status::DescribeRemediationExecutionStatusError::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   
        "NoSuchRemediationConfigurationException" => {
   62     56   
            crate::operation::describe_remediation_execution_status::DescribeRemediationExecutionStatusError::NoSuchRemediationConfigurationException(
   63     57   
                {
   64     58   
                    #[allow(unused_mut)]
   65     59   
                    let mut tmp = {
   66     60   
                        #[allow(unused_mut)]
   67     61   
                        let mut output = crate::types::error::builders::NoSuchRemediationConfigurationExceptionBuilder::default();
   68     62   
                        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::describe_remediation_execution_status::DescribeRemediationExecutionStatusError::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   
        }
   79     70   
        _ => crate::operation::describe_remediation_execution_status::DescribeRemediationExecutionStatusError::generic(generic),
   80     71   
    })
   81     72   
}
   82     73   
   83     74   
#[allow(clippy::unnecessary_wraps)]
   84     75   
pub fn de_describe_remediation_execution_status_http_response(

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

@@ -5,5 +103,94 @@
   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_retention_configurations::DescribeRetentionConfigurationsError::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_retention_configurations::DescribeRetentionConfigurationsError::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_retention_configurations::DescribeRetentionConfigurationsError::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   
        "NoSuchRetentionConfigurationException" => {
   62     56   
            crate::operation::describe_retention_configurations::DescribeRetentionConfigurationsError::NoSuchRetentionConfigurationException({
   63     57   
                #[allow(unused_mut)]
   64     58   
                let mut tmp = {
   65     59   
                    #[allow(unused_mut)]
   66     60   
                    let mut output = crate::types::error::builders::NoSuchRetentionConfigurationExceptionBuilder::default();
   67     61   
                    output = crate::protocol_serde::shape_no_such_retention_configuration_exception::de_no_such_retention_configuration_exception_json_err(_response_body, output).map_err(crate::operation::describe_retention_configurations::DescribeRetentionConfigurationsError::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   
        _ => crate::operation::describe_retention_configurations::DescribeRetentionConfigurationsError::generic(generic),
   78     69   
    })
   79     70   
}
   80     71   
   81     72   
#[allow(clippy::unnecessary_wraps)]
   82     73   
pub fn de_describe_retention_configurations_http_response(
   83     74   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_get_aggregate_compliance_details_by_config_rule.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::get_aggregate_compliance_details_by_config_rule::GetAggregateComplianceDetailsByConfigRuleError::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::get_aggregate_compliance_details_by_config_rule::GetAggregateComplianceDetailsByConfigRuleError::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::get_aggregate_compliance_details_by_config_rule::GetAggregateComplianceDetailsByConfigRuleError::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::get_aggregate_compliance_details_by_config_rule::GetAggregateComplianceDetailsByConfigRuleError::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::get_aggregate_compliance_details_by_config_rule::GetAggregateComplianceDetailsByConfigRuleError::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::get_aggregate_compliance_details_by_config_rule::GetAggregateComplianceDetailsByConfigRuleError::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::get_aggregate_compliance_details_by_config_rule::GetAggregateComplianceDetailsByConfigRuleError::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::get_aggregate_compliance_details_by_config_rule::GetAggregateComplianceDetailsByConfigRuleError::generic(generic)
   92     80   
    })
   93     81   
}
   94     82   
   95     83   
#[allow(clippy::unnecessary_wraps)]
   96     84   
pub fn de_get_aggregate_compliance_details_by_config_rule_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_get_aggregate_config_rule_compliance_summary.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::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::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::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::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::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::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::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::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::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::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::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::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::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::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::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::generic(generic)
   92     80   
    })
   93     81   
}
   94     82   
   95     83   
#[allow(clippy::unnecessary_wraps)]
   96     84   
pub fn de_get_aggregate_config_rule_compliance_summary_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_get_aggregate_conformance_pack_compliance_summary.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::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::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::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::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::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::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::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::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::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::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::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::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::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::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::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::generic(generic)
   94     82   
    })
   95     83   
}
   96     84   
   97     85   
#[allow(clippy::unnecessary_wraps)]
   98     86   
pub fn de_get_aggregate_conformance_pack_compliance_summary_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_get_aggregate_discovered_resource_counts.rs

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

@@ -3,3 +121,109 @@
   23     23   
        "NoSuchConfigurationAggregatorException" => {
   24     24   
            crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::NoSuchConfigurationAggregatorException({
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::NoSuchConfigurationAggregatorExceptionBuilder::default();
   29     29   
                    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::get_aggregate_resource_config::GetAggregateResourceConfigError::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   
        "OversizedConfigurationItemException" => {
   40     37   
            crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::OversizedConfigurationItemException({
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut tmp = {
   43     40   
                    #[allow(unused_mut)]
   44     41   
                    let mut output = crate::types::error::builders::OversizedConfigurationItemExceptionBuilder::default();
   45     42   
                    output = crate::protocol_serde::shape_oversized_configuration_item_exception::de_oversized_configuration_item_exception_json_err(
   46     43   
                        _response_body,
   47     44   
                        output,
   48     45   
                    )
   49     46   
                    .map_err(crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::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   
        }
   59     53   
        "ResourceNotDiscoveredException" => {
   60     54   
            crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::ResourceNotDiscoveredException({
   61     55   
                #[allow(unused_mut)]
   62     56   
                let mut tmp = {
   63     57   
                    #[allow(unused_mut)]
   64     58   
                    let mut output = crate::types::error::builders::ResourceNotDiscoveredExceptionBuilder::default();
   65     59   
                    output = crate::protocol_serde::shape_resource_not_discovered_exception::de_resource_not_discovered_exception_json_err(
   66     60   
                        _response_body,
   67     61   
                        output,
   68     62   
                    )
   69     63   
                    .map_err(crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::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   
        "ValidationException" => crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::ValidationException({
   80     71   
            #[allow(unused_mut)]
   81     72   
            let mut tmp = {
   82     73   
                #[allow(unused_mut)]
   83     74   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   84     75   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   85     76   
                    .map_err(crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::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   
        _ => crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::generic(generic),
   95     83   
    })
   96     84   
}
   97     85   
   98     86   
#[allow(clippy::unnecessary_wraps)]
   99     87   
pub fn de_get_aggregate_resource_config_http_response(
  100     88   
    _response_status: u16,
  101     89   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_get_compliance_details_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::get_compliance_details_by_config_rule::GetComplianceDetailsByConfigRuleError::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::get_compliance_details_by_config_rule::GetComplianceDetailsByConfigRuleError::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::get_compliance_details_by_config_rule::GetComplianceDetailsByConfigRuleError::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::get_compliance_details_by_config_rule::GetComplianceDetailsByConfigRuleError::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::get_compliance_details_by_config_rule::GetComplianceDetailsByConfigRuleError::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::get_compliance_details_by_config_rule::GetComplianceDetailsByConfigRuleError::generic(generic),
   80     71   
    })
   81     72   
}
   82     73   
   83     74   
#[allow(clippy::unnecessary_wraps)]
   84     75   
pub fn de_get_compliance_details_by_config_rule_http_response(
   85     76   
    _response_status: u16,