AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df (ignoring whitespace)

Files changed:

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

@@ -3,3 +81,75 @@
   23     23   
        "NoSuchConfigurationAggregatorException" => {
   24     24   
            crate::operation::batch_get_aggregate_resource_config::BatchGetAggregateResourceConfigError::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::batch_get_aggregate_resource_config::BatchGetAggregateResourceConfigError::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   
        "ValidationException" => crate::operation::batch_get_aggregate_resource_config::BatchGetAggregateResourceConfigError::ValidationException({
   40     37   
            #[allow(unused_mut)]
   41     38   
            let mut tmp = {
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   44     41   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   45     42   
                    .map_err(crate::operation::batch_get_aggregate_resource_config::BatchGetAggregateResourceConfigError::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   
        _ => crate::operation::batch_get_aggregate_resource_config::BatchGetAggregateResourceConfigError::generic(generic),
   55     49   
    })
   56     50   
}
   57     51   
   58     52   
#[allow(clippy::unnecessary_wraps)]
   59     53   
pub fn de_batch_get_aggregate_resource_config_http_response(
   60     54   
    _response_status: u16,
   61     55   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +85,79 @@
   27     27   
        "NoAvailableConfigurationRecorderException" => {
   28     28   
            crate::operation::batch_get_resource_config::BatchGetResourceConfigError::NoAvailableConfigurationRecorderException({
   29     29   
                #[allow(unused_mut)]
   30     30   
                let mut tmp = {
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::NoAvailableConfigurationRecorderExceptionBuilder::default();
   33     33   
                    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::batch_get_resource_config::BatchGetResourceConfigError::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   
        "ValidationException" => crate::operation::batch_get_resource_config::BatchGetResourceConfigError::ValidationException({
   44     41   
            #[allow(unused_mut)]
   45     42   
            let mut tmp = {
   46     43   
                #[allow(unused_mut)]
   47     44   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   48     45   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   49     46   
                    .map_err(crate::operation::batch_get_resource_config::BatchGetResourceConfigError::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   
        _ => crate::operation::batch_get_resource_config::BatchGetResourceConfigError::generic(generic),
   59     53   
    })
   60     54   
}
   61     55   
   62     56   
#[allow(clippy::unnecessary_wraps)]
   63     57   
pub fn de_batch_get_resource_config_http_response(
   64     58   
    _response_status: u16,
   65     59   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

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

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

@@ -1,1 +77,71 @@
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::NoSuchConfigRuleExceptionBuilder::default();
   25     25   
                output =
   26     26   
                    crate::protocol_serde::shape_no_such_config_rule_exception::de_no_such_config_rule_exception_json_err(_response_body, output)
   27     27   
                        .map_err(crate::operation::delete_config_rule::DeleteConfigRuleError::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   
        "ResourceInUseException" => crate::operation::delete_config_rule::DeleteConfigRuleError::ResourceInUseException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::delete_config_rule::DeleteConfigRuleError::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_config_rule::DeleteConfigRuleError::generic(generic),
   52     46   
    })
   53     47   
}
   54     48   
   55     49   
#[allow(clippy::unnecessary_wraps)]
   56     50   
pub fn de_delete_config_rule_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_delete_configuration_aggregator.rs

@@ -3,3 +65,62 @@
   23     23   
        "NoSuchConfigurationAggregatorException" => {
   24     24   
            crate::operation::delete_configuration_aggregator::DeleteConfigurationAggregatorError::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::delete_configuration_aggregator::DeleteConfigurationAggregatorError::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   
        _ => crate::operation::delete_configuration_aggregator::DeleteConfigurationAggregatorError::generic(generic),
   40     37   
    })
   41     38   
}
   42     39   
   43     40   
#[allow(clippy::unnecessary_wraps)]
   44     41   
pub fn de_delete_configuration_aggregator_http_response(
   45     42   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_delete_configuration_recorder.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::delete_configuration_recorder::DeleteConfigurationRecorderError::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::delete_configuration_recorder::DeleteConfigurationRecorderError::generic(generic),
   45     42   
    })
   46     43   
}
   47     44   
   48     45   
#[allow(clippy::unnecessary_wraps)]
   49     46   
pub fn de_delete_configuration_recorder_http_response(
   50     47   
    _response_status: u16,

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

@@ -6,6 +83,77 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::NoSuchConformancePackExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_no_such_conformance_pack_exception::de_no_such_conformance_pack_exception_json_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::delete_conformance_pack::DeleteConformancePackError::unhandled)?;
   33     33   
                let output = output.meta(generic);
   34     34   
                output.build()
   35     35   
            };
   36         -
            if tmp.message.is_none() {
   37         -
                tmp.message = _error_message;
   38         -
            }
   39     36   
            tmp
   40     37   
        }),
   41     38   
        "ResourceInUseException" => crate::operation::delete_conformance_pack::DeleteConformancePackError::ResourceInUseException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::delete_conformance_pack::DeleteConformancePackError::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   
        _ => crate::operation::delete_conformance_pack::DeleteConformancePackError::generic(generic),
   57     51   
    })
   58     52   
}
   59     53   
   60     54   
#[allow(clippy::unnecessary_wraps)]
   61     55   
pub fn de_delete_conformance_pack_http_response(
   62     56   
    _response_status: u16,
   63     57   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +84,78 @@
   23     23   
        "LastDeliveryChannelDeleteFailedException" => {
   24     24   
            crate::operation::delete_delivery_channel::DeleteDeliveryChannelError::LastDeliveryChannelDeleteFailedException({
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::LastDeliveryChannelDeleteFailedExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_last_delivery_channel_delete_failed_exception::de_last_delivery_channel_delete_failed_exception_json_err(_response_body, output).map_err(crate::operation::delete_delivery_channel::DeleteDeliveryChannelError::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   
        "NoSuchDeliveryChannelException" => crate::operation::delete_delivery_channel::DeleteDeliveryChannelError::NoSuchDeliveryChannelException({
   40     37   
            #[allow(unused_mut)]
   41     38   
            let mut tmp = {
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut output = crate::types::error::builders::NoSuchDeliveryChannelExceptionBuilder::default();
   44     41   
                output = crate::protocol_serde::shape_no_such_delivery_channel_exception::de_no_such_delivery_channel_exception_json_err(
   45     42   
                    _response_body,
   46     43   
                    output,
   47     44   
                )
   48     45   
                .map_err(crate::operation::delete_delivery_channel::DeleteDeliveryChannelError::unhandled)?;
   49     46   
                let output = output.meta(generic);
   50     47   
                output.build()
   51     48   
            };
   52         -
            if tmp.message.is_none() {
   53         -
                tmp.message = _error_message;
   54         -
            }
   55     49   
            tmp
   56     50   
        }),
   57     51   
        _ => crate::operation::delete_delivery_channel::DeleteDeliveryChannelError::generic(generic),
   58     52   
    })
   59     53   
}
   60     54   
   61     55   
#[allow(clippy::unnecessary_wraps)]
   62     56   
pub fn de_delete_delivery_channel_http_response(
   63     57   
    _response_status: u16,
   64     58   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -8,8 +85,79 @@
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::NoSuchConfigRuleExceptionBuilder::default();
   32     32   
                output =
   33     33   
                    crate::protocol_serde::shape_no_such_config_rule_exception::de_no_such_config_rule_exception_json_err(_response_body, output)
   34     34   
                        .map_err(crate::operation::delete_evaluation_results::DeleteEvaluationResultsError::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   
        "ResourceInUseException" => crate::operation::delete_evaluation_results::DeleteEvaluationResultsError::ResourceInUseException({
   44     41   
            #[allow(unused_mut)]
   45     42   
            let mut tmp = {
   46     43   
                #[allow(unused_mut)]
   47     44   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   48     45   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   49     46   
                    .map_err(crate::operation::delete_evaluation_results::DeleteEvaluationResultsError::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   
        _ => crate::operation::delete_evaluation_results::DeleteEvaluationResultsError::generic(generic),
   59     53   
    })
   60     54   
}
   61     55   
   62     56   
#[allow(clippy::unnecessary_wraps)]
   63     57   
pub fn de_delete_evaluation_results_http_response(
   64     58   
    _response_status: u16,
   65     59   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +101,92 @@
   23     23   
        "NoSuchOrganizationConfigRuleException" => {
   24     24   
            crate::operation::delete_organization_config_rule::DeleteOrganizationConfigRuleError::NoSuchOrganizationConfigRuleException({
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::NoSuchOrganizationConfigRuleExceptionBuilder::default();
   29     29   
                    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::delete_organization_config_rule::DeleteOrganizationConfigRuleError::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   
        "OrganizationAccessDeniedException" => {
   40     37   
            crate::operation::delete_organization_config_rule::DeleteOrganizationConfigRuleError::OrganizationAccessDeniedException({
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut tmp = {
   43     40   
                    #[allow(unused_mut)]
   44     41   
                    let mut output = crate::types::error::builders::OrganizationAccessDeniedExceptionBuilder::default();
   45     42   
                    output = crate::protocol_serde::shape_organization_access_denied_exception::de_organization_access_denied_exception_json_err(
   46     43   
                        _response_body,
   47     44   
                        output,
   48     45   
                    )
   49     46   
                    .map_err(crate::operation::delete_organization_config_rule::DeleteOrganizationConfigRuleError::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   
        "ResourceInUseException" => crate::operation::delete_organization_config_rule::DeleteOrganizationConfigRuleError::ResourceInUseException({
   60     54   
            #[allow(unused_mut)]
   61     55   
            let mut tmp = {
   62     56   
                #[allow(unused_mut)]
   63     57   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   64     58   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   65     59   
                    .map_err(crate::operation::delete_organization_config_rule::DeleteOrganizationConfigRuleError::unhandled)?;
   66     60   
                let output = output.meta(generic);
   67     61   
                output.build()
   68     62   
            };
   69         -
            if tmp.message.is_none() {
   70         -
                tmp.message = _error_message;
   71         -
            }
   72     63   
            tmp
   73     64   
        }),
   74     65   
        _ => crate::operation::delete_organization_config_rule::DeleteOrganizationConfigRuleError::generic(generic),
   75     66   
    })
   76     67   
}
   77     68   
   78     69   
#[allow(clippy::unnecessary_wraps)]
   79     70   
pub fn de_delete_organization_config_rule_http_response(
   80     71   
    _response_status: u16,
   81     72   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -4,4 +104,95 @@
   24     24   
            crate::operation::delete_organization_conformance_pack::DeleteOrganizationConformancePackError::NoSuchOrganizationConformancePackException(
   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::NoSuchOrganizationConformancePackExceptionBuilder::default();
   30     30   
                        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::delete_organization_conformance_pack::DeleteOrganizationConformancePackError::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   
        "OrganizationAccessDeniedException" => {
   42     39   
            crate::operation::delete_organization_conformance_pack::DeleteOrganizationConformancePackError::OrganizationAccessDeniedException({
   43     40   
                #[allow(unused_mut)]
   44     41   
                let mut tmp = {
   45     42   
                    #[allow(unused_mut)]
   46     43   
                    let mut output = crate::types::error::builders::OrganizationAccessDeniedExceptionBuilder::default();
   47     44   
                    output = crate::protocol_serde::shape_organization_access_denied_exception::de_organization_access_denied_exception_json_err(
   48     45   
                        _response_body,
   49     46   
                        output,
   50     47   
                    )
   51     48   
                    .map_err(crate::operation::delete_organization_conformance_pack::DeleteOrganizationConformancePackError::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   
        "ResourceInUseException" => {
   62     56   
            crate::operation::delete_organization_conformance_pack::DeleteOrganizationConformancePackError::ResourceInUseException({
   63     57   
                #[allow(unused_mut)]
   64     58   
                let mut tmp = {
   65     59   
                    #[allow(unused_mut)]
   66     60   
                    let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   67     61   
                    output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   68     62   
                        .map_err(crate::operation::delete_organization_conformance_pack::DeleteOrganizationConformancePackError::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::delete_organization_conformance_pack::DeleteOrganizationConformancePackError::generic(generic),
   79     70   
    })
   80     71   
}
   81     72   
   82     73   
#[allow(clippy::unnecessary_wraps)]
   83     74   
pub fn de_delete_organization_conformance_pack_http_response(
   84     75   
    _response_status: u16,

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

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

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

@@ -7,7 +125,113 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InsufficientPermissionsExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_insufficient_permissions_exception::de_insufficient_permissions_exception_json_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::delete_remediation_configuration::DeleteRemediationConfigurationError::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   
        "InvalidParameterValueException" => {
   44     41   
            crate::operation::delete_remediation_configuration::DeleteRemediationConfigurationError::InvalidParameterValueException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   49     46   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   50     47   
                        _response_body,
   51     48   
                        output,
   52     49   
                    )
   53     50   
                    .map_err(crate::operation::delete_remediation_configuration::DeleteRemediationConfigurationError::unhandled)?;
   54     51   
                    let output = output.meta(generic);
   55     52   
                    output.build()
   56     53   
                };
   57         -
                if tmp.message.is_none() {
   58         -
                    tmp.message = _error_message;
   59         -
                }
   60     54   
                tmp
   61     55   
            })
   62     56   
        }
   63     57   
        "NoSuchRemediationConfigurationException" => {
   64     58   
            crate::operation::delete_remediation_configuration::DeleteRemediationConfigurationError::NoSuchRemediationConfigurationException({
   65     59   
                #[allow(unused_mut)]
   66     60   
                let mut tmp = {
   67     61   
                    #[allow(unused_mut)]
   68     62   
                    let mut output = crate::types::error::builders::NoSuchRemediationConfigurationExceptionBuilder::default();
   69     63   
                    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::delete_remediation_configuration::DeleteRemediationConfigurationError::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   
        "RemediationInProgressException" => {
   80     71   
            crate::operation::delete_remediation_configuration::DeleteRemediationConfigurationError::RemediationInProgressException({
   81     72   
                #[allow(unused_mut)]
   82     73   
                let mut tmp = {
   83     74   
                    #[allow(unused_mut)]
   84     75   
                    let mut output = crate::types::error::builders::RemediationInProgressExceptionBuilder::default();
   85     76   
                    output = crate::protocol_serde::shape_remediation_in_progress_exception::de_remediation_in_progress_exception_json_err(
   86     77   
                        _response_body,
   87     78   
                        output,
   88     79   
                    )
   89     80   
                    .map_err(crate::operation::delete_remediation_configuration::DeleteRemediationConfigurationError::unhandled)?;
   90     81   
                    let output = output.meta(generic);
   91     82   
                    output.build()
   92     83   
                };
   93         -
                if tmp.message.is_none() {
   94         -
                    tmp.message = _error_message;
   95         -
                }
   96     84   
                tmp
   97     85   
            })
   98     86   
        }
   99     87   
        _ => crate::operation::delete_remediation_configuration::DeleteRemediationConfigurationError::generic(generic),
  100     88   
    })
  101     89   
}
  102     90   
  103     91   
#[allow(clippy::unnecessary_wraps)]
  104     92   
pub fn de_delete_remediation_configuration_http_response(
  105     93   
    _response_status: u16,

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

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

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

@@ -3,3 +81,75 @@
   23     23   
        "NoRunningConfigurationRecorderException" => {
   24     24   
            crate::operation::delete_resource_config::DeleteResourceConfigError::NoRunningConfigurationRecorderException({
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::NoRunningConfigurationRecorderExceptionBuilder::default();
   29     29   
                    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::delete_resource_config::DeleteResourceConfigError::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   
        "ValidationException" => crate::operation::delete_resource_config::DeleteResourceConfigError::ValidationException({
   40     37   
            #[allow(unused_mut)]
   41     38   
            let mut tmp = {
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   44     41   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   45     42   
                    .map_err(crate::operation::delete_resource_config::DeleteResourceConfigError::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   
        _ => crate::operation::delete_resource_config::DeleteResourceConfigError::generic(generic),
   55     49   
    })
   56     50   
}
   57     51   
   58     52   
#[allow(clippy::unnecessary_wraps)]
   59     53   
pub fn de_delete_resource_config_http_response(
   60     54   
    _response_status: u16,
   61     55   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +85,79 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::delete_retention_configuration::DeleteRetentionConfigurationError::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   
        "NoSuchRetentionConfigurationException" => {
   44     41   
            crate::operation::delete_retention_configuration::DeleteRetentionConfigurationError::NoSuchRetentionConfigurationException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::NoSuchRetentionConfigurationExceptionBuilder::default();
   49     46   
                    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::delete_retention_configuration::DeleteRetentionConfigurationError::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   
        _ => crate::operation::delete_retention_configuration::DeleteRetentionConfigurationError::generic(generic),
   60     54   
    })
   61     55   
}
   62     56   
   63     57   
#[allow(clippy::unnecessary_wraps)]
   64     58   
pub fn de_delete_retention_configuration_http_response(
   65     59   
    _response_status: u16,