AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df (ignoring whitespace)

Files changed:

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

@@ -1,1 +78,72 @@
   21     21   
        "InvalidNextTokenException" => crate::operation::list_stored_queries::ListStoredQueriesError::InvalidNextTokenException({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::list_stored_queries::ListStoredQueriesError::unhandled)?;
   28     28   
                let output = output.meta(generic);
   29     29   
                output.build()
   30     30   
            };
   31         -
            if tmp.message.is_none() {
   32         -
                tmp.message = _error_message;
   33         -
            }
   34     31   
            tmp
   35     32   
        }),
   36     33   
        "ValidationException" => crate::operation::list_stored_queries::ListStoredQueriesError::ValidationException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::list_stored_queries::ListStoredQueriesError::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::list_stored_queries::ListStoredQueriesError::generic(generic),
   52     46   
    })
   53     47   
}
   54     48   
   55     49   
#[allow(clippy::unnecessary_wraps)]
   56     50   
pub fn de_list_stored_queries_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_list_tags_for_resource.rs

@@ -3,3 +110,98 @@
   23     23   
        "InvalidLimitException" => crate::operation::list_tags_for_resource::ListTagsForResourceError::InvalidLimitException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidLimitExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_limit_exception::de_invalid_limit_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::list_tags_for_resource::ListTagsForResourceError::unhandled)?;
   30     30   
                let output = output.meta(generic);
   31     31   
                output.build()
   32     32   
            };
   33         -
            if tmp.message.is_none() {
   34         -
                tmp.message = _error_message;
   35         -
            }
   36     33   
            tmp
   37     34   
        }),
   38     35   
        "InvalidNextTokenException" => crate::operation::list_tags_for_resource::ListTagsForResourceError::InvalidNextTokenException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::list_tags_for_resource::ListTagsForResourceError::unhandled)?;
   45     42   
                let output = output.meta(generic);
   46     43   
                output.build()
   47     44   
            };
   48         -
            if tmp.message.is_none() {
   49         -
                tmp.message = _error_message;
   50         -
            }
   51     45   
            tmp
   52     46   
        }),
   53     47   
        "ResourceNotFoundException" => crate::operation::list_tags_for_resource::ListTagsForResourceError::ResourceNotFoundException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::list_tags_for_resource::ListTagsForResourceError::unhandled)?;
   60     54   
                let output = output.meta(generic);
   61     55   
                output.build()
   62     56   
            };
   63         -
            if tmp.message.is_none() {
   64         -
                tmp.message = _error_message;
   65         -
            }
   66     57   
            tmp
   67     58   
        }),
   68     59   
        "ValidationException" => crate::operation::list_tags_for_resource::ListTagsForResourceError::ValidationException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::list_tags_for_resource::ListTagsForResourceError::unhandled)?;
   75     66   
                let output = output.meta(generic);
   76     67   
                output.build()
   77     68   
            };
   78         -
            if tmp.message.is_none() {
   79         -
                tmp.message = _error_message;
   80         -
            }
   81     69   
            tmp
   82     70   
        }),
   83     71   
        _ => crate::operation::list_tags_for_resource::ListTagsForResourceError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_list_tags_for_resource_http_response(
   89     77   
    _response_status: u16,
   90     78   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/config/src/protocol_serde/shape_put_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::put_aggregation_authorization::PutAggregationAuthorizationError::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::put_aggregation_authorization::PutAggregationAuthorizationError::generic(generic),
   44     41   
    })
   45     42   
}
   46     43   
   47     44   
#[allow(clippy::unnecessary_wraps)]
   48     45   
pub fn de_put_aggregation_authorization_http_response(
   49     46   
    _response_status: u16,

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

@@ -3,3 +129,114 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InsufficientPermissionsExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_insufficient_permissions_exception::de_insufficient_permissions_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::put_config_rule::PutConfigRuleError::unhandled)?;
   30     30   
                let output = output.meta(generic);
   31     31   
                output.build()
   32     32   
            };
   33         -
            if tmp.message.is_none() {
   34         -
                tmp.message = _error_message;
   35         -
            }
   36     33   
            tmp
   37     34   
        }),
   38     35   
        "InvalidParameterValueException" => crate::operation::put_config_rule::PutConfigRuleError::InvalidParameterValueException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   44     41   
                    _response_body,
   45     42   
                    output,
   46     43   
                )
   47     44   
                .map_err(crate::operation::put_config_rule::PutConfigRuleError::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   
        "MaxNumberOfConfigRulesExceededException" => {
   57     51   
            crate::operation::put_config_rule::PutConfigRuleError::MaxNumberOfConfigRulesExceededException({
   58     52   
                #[allow(unused_mut)]
   59     53   
                let mut tmp = {
   60     54   
                    #[allow(unused_mut)]
   61     55   
                    let mut output = crate::types::error::builders::MaxNumberOfConfigRulesExceededExceptionBuilder::default();
   62     56   
                    output = crate::protocol_serde::shape_max_number_of_config_rules_exceeded_exception::de_max_number_of_config_rules_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::put_config_rule::PutConfigRuleError::unhandled)?;
   63     57   
                    let output = output.meta(generic);
   64     58   
                    output.build()
   65     59   
                };
   66         -
                if tmp.message.is_none() {
   67         -
                    tmp.message = _error_message;
   68         -
                }
   69     60   
                tmp
   70     61   
            })
   71     62   
        }
   72     63   
        "NoAvailableConfigurationRecorderException" => {
   73     64   
            crate::operation::put_config_rule::PutConfigRuleError::NoAvailableConfigurationRecorderException({
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut tmp = {
   76     67   
                    #[allow(unused_mut)]
   77     68   
                    let mut output = crate::types::error::builders::NoAvailableConfigurationRecorderExceptionBuilder::default();
   78     69   
                    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::put_config_rule::PutConfigRuleError::unhandled)?;
   79     70   
                    let output = output.meta(generic);
   80     71   
                    output.build()
   81     72   
                };
   82         -
                if tmp.message.is_none() {
   83         -
                    tmp.message = _error_message;
   84         -
                }
   85     73   
                tmp
   86     74   
            })
   87     75   
        }
   88     76   
        "ResourceInUseException" => crate::operation::put_config_rule::PutConfigRuleError::ResourceInUseException({
   89     77   
            #[allow(unused_mut)]
   90     78   
            let mut tmp = {
   91     79   
                #[allow(unused_mut)]
   92     80   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   93     81   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   94     82   
                    .map_err(crate::operation::put_config_rule::PutConfigRuleError::unhandled)?;
   95     83   
                let output = output.meta(generic);
   96     84   
                output.build()
   97     85   
            };
   98         -
            if tmp.message.is_none() {
   99         -
                tmp.message = _error_message;
  100         -
            }
  101     86   
            tmp
  102     87   
        }),
  103     88   
        _ => crate::operation::put_config_rule::PutConfigRuleError::generic(generic),
  104     89   
    })
  105     90   
}
  106     91   
  107     92   
#[allow(clippy::unnecessary_wraps)]
  108     93   
pub fn de_put_config_rule_http_response(
  109     94   
    _response_status: u16,
  110     95   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +155,137 @@
   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::put_configuration_aggregator::PutConfigurationAggregatorError::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   
        "InvalidRoleException" => crate::operation::put_configuration_aggregator::PutConfigurationAggregatorError::InvalidRoleException({
   44     41   
            #[allow(unused_mut)]
   45     42   
            let mut tmp = {
   46     43   
                #[allow(unused_mut)]
   47     44   
                let mut output = crate::types::error::builders::InvalidRoleExceptionBuilder::default();
   48     45   
                output = crate::protocol_serde::shape_invalid_role_exception::de_invalid_role_exception_json_err(_response_body, output)
   49     46   
                    .map_err(crate::operation::put_configuration_aggregator::PutConfigurationAggregatorError::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   
        "LimitExceededException" => crate::operation::put_configuration_aggregator::PutConfigurationAggregatorError::LimitExceededException({
   59     53   
            #[allow(unused_mut)]
   60     54   
            let mut tmp = {
   61     55   
                #[allow(unused_mut)]
   62     56   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   63     57   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   64     58   
                    .map_err(crate::operation::put_configuration_aggregator::PutConfigurationAggregatorError::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   
        "NoAvailableOrganizationException" => {
   74     65   
            crate::operation::put_configuration_aggregator::PutConfigurationAggregatorError::NoAvailableOrganizationException({
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut tmp = {
   77     68   
                    #[allow(unused_mut)]
   78     69   
                    let mut output = crate::types::error::builders::NoAvailableOrganizationExceptionBuilder::default();
   79     70   
                    output = crate::protocol_serde::shape_no_available_organization_exception::de_no_available_organization_exception_json_err(
   80     71   
                        _response_body,
   81     72   
                        output,
   82     73   
                    )
   83     74   
                    .map_err(crate::operation::put_configuration_aggregator::PutConfigurationAggregatorError::unhandled)?;
   84     75   
                    let output = output.meta(generic);
   85     76   
                    output.build()
   86     77   
                };
   87         -
                if tmp.message.is_none() {
   88         -
                    tmp.message = _error_message;
   89         -
                }
   90     78   
                tmp
   91     79   
            })
   92     80   
        }
   93     81   
        "OrganizationAccessDeniedException" => {
   94     82   
            crate::operation::put_configuration_aggregator::PutConfigurationAggregatorError::OrganizationAccessDeniedException({
   95     83   
                #[allow(unused_mut)]
   96     84   
                let mut tmp = {
   97     85   
                    #[allow(unused_mut)]
   98     86   
                    let mut output = crate::types::error::builders::OrganizationAccessDeniedExceptionBuilder::default();
   99     87   
                    output = crate::protocol_serde::shape_organization_access_denied_exception::de_organization_access_denied_exception_json_err(
  100     88   
                        _response_body,
  101     89   
                        output,
  102     90   
                    )
  103     91   
                    .map_err(crate::operation::put_configuration_aggregator::PutConfigurationAggregatorError::unhandled)?;
  104     92   
                    let output = output.meta(generic);
  105     93   
                    output.build()
  106     94   
                };
  107         -
                if tmp.message.is_none() {
  108         -
                    tmp.message = _error_message;
  109         -
                }
  110     95   
                tmp
  111     96   
            })
  112     97   
        }
  113     98   
        "OrganizationAllFeaturesNotEnabledException" => {
  114     99   
            crate::operation::put_configuration_aggregator::PutConfigurationAggregatorError::OrganizationAllFeaturesNotEnabledException({
  115    100   
                #[allow(unused_mut)]
  116    101   
                let mut tmp = {
  117    102   
                    #[allow(unused_mut)]
  118    103   
                    let mut output = crate::types::error::builders::OrganizationAllFeaturesNotEnabledExceptionBuilder::default();
  119    104   
                    output = crate::protocol_serde::shape_organization_all_features_not_enabled_exception::de_organization_all_features_not_enabled_exception_json_err(_response_body, output).map_err(crate::operation::put_configuration_aggregator::PutConfigurationAggregatorError::unhandled)?;
  120    105   
                    let output = output.meta(generic);
  121    106   
                    output.build()
  122    107   
                };
  123         -
                if tmp.message.is_none() {
  124         -
                    tmp.message = _error_message;
  125         -
                }
  126    108   
                tmp
  127    109   
            })
  128    110   
        }
  129    111   
        _ => crate::operation::put_configuration_aggregator::PutConfigurationAggregatorError::generic(generic),
  130    112   
    })
  131    113   
}
  132    114   
  133    115   
#[allow(clippy::unnecessary_wraps)]
  134    116   
pub fn de_put_configuration_aggregator_http_response(
  135    117   
    _response_status: u16,

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

@@ -7,7 +136,121 @@
   27     27   
        "InvalidConfigurationRecorderNameException" => {
   28     28   
            crate::operation::put_configuration_recorder::PutConfigurationRecorderError::InvalidConfigurationRecorderNameException({
   29     29   
                #[allow(unused_mut)]
   30     30   
                let mut tmp = {
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidConfigurationRecorderNameExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_configuration_recorder_name_exception::de_invalid_configuration_recorder_name_exception_json_err(_response_body, output).map_err(crate::operation::put_configuration_recorder::PutConfigurationRecorderError::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   
        "InvalidRecordingGroupException" => {
   44     41   
            crate::operation::put_configuration_recorder::PutConfigurationRecorderError::InvalidRecordingGroupException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::InvalidRecordingGroupExceptionBuilder::default();
   49     46   
                    output = crate::protocol_serde::shape_invalid_recording_group_exception::de_invalid_recording_group_exception_json_err(
   50     47   
                        _response_body,
   51     48   
                        output,
   52     49   
                    )
   53     50   
                    .map_err(crate::operation::put_configuration_recorder::PutConfigurationRecorderError::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   
        "InvalidRoleException" => crate::operation::put_configuration_recorder::PutConfigurationRecorderError::InvalidRoleException({
   64     58   
            #[allow(unused_mut)]
   65     59   
            let mut tmp = {
   66     60   
                #[allow(unused_mut)]
   67     61   
                let mut output = crate::types::error::builders::InvalidRoleExceptionBuilder::default();
   68     62   
                output = crate::protocol_serde::shape_invalid_role_exception::de_invalid_role_exception_json_err(_response_body, output)
   69     63   
                    .map_err(crate::operation::put_configuration_recorder::PutConfigurationRecorderError::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   
        "MaxNumberOfConfigurationRecordersExceededException" => {
   79     70   
            crate::operation::put_configuration_recorder::PutConfigurationRecorderError::MaxNumberOfConfigurationRecordersExceededException({
   80     71   
                #[allow(unused_mut)]
   81     72   
                let mut tmp = {
   82     73   
                    #[allow(unused_mut)]
   83     74   
                    let mut output = crate::types::error::builders::MaxNumberOfConfigurationRecordersExceededExceptionBuilder::default();
   84     75   
                    output = crate::protocol_serde::shape_max_number_of_configuration_recorders_exceeded_exception::de_max_number_of_configuration_recorders_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::put_configuration_recorder::PutConfigurationRecorderError::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   
        "ValidationException" => crate::operation::put_configuration_recorder::PutConfigurationRecorderError::ValidationException({
   95     83   
            #[allow(unused_mut)]
   96     84   
            let mut tmp = {
   97     85   
                #[allow(unused_mut)]
   98     86   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   99     87   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  100     88   
                    .map_err(crate::operation::put_configuration_recorder::PutConfigurationRecorderError::unhandled)?;
  101     89   
                let output = output.meta(generic);
  102     90   
                output.build()
  103     91   
            };
  104         -
            if tmp.message.is_none() {
  105         -
                tmp.message = _error_message;
  106         -
            }
  107     92   
            tmp
  108     93   
        }),
  109     94   
        _ => crate::operation::put_configuration_recorder::PutConfigurationRecorderError::generic(generic),
  110     95   
    })
  111     96   
}
  112     97   
  113     98   
#[allow(clippy::unnecessary_wraps)]
  114     99   
pub fn de_put_configuration_recorder_http_response(
  115    100   
    _response_status: u16,
  116    101   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +133,118 @@
   23     23   
        "ConformancePackTemplateValidationException" => {
   24     24   
            crate::operation::put_conformance_pack::PutConformancePackError::ConformancePackTemplateValidationException({
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::ConformancePackTemplateValidationExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_conformance_pack_template_validation_exception::de_conformance_pack_template_validation_exception_json_err(_response_body, output).map_err(crate::operation::put_conformance_pack::PutConformancePackError::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   
        "InsufficientPermissionsException" => crate::operation::put_conformance_pack::PutConformancePackError::InsufficientPermissionsException({
   40     37   
            #[allow(unused_mut)]
   41     38   
            let mut tmp = {
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut output = crate::types::error::builders::InsufficientPermissionsExceptionBuilder::default();
   44     41   
                output = crate::protocol_serde::shape_insufficient_permissions_exception::de_insufficient_permissions_exception_json_err(
   45     42   
                    _response_body,
   46     43   
                    output,
   47     44   
                )
   48     45   
                .map_err(crate::operation::put_conformance_pack::PutConformancePackError::unhandled)?;
   49     46   
                let output = output.meta(generic);
   50     47   
                output.build()
   51     48   
            };
   52         -
            if tmp.message.is_none() {
   53         -
                tmp.message = _error_message;
   54         -
            }
   55     49   
            tmp
   56     50   
        }),
   57     51   
        "InvalidParameterValueException" => crate::operation::put_conformance_pack::PutConformancePackError::InvalidParameterValueException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   63     57   
                    _response_body,
   64     58   
                    output,
   65     59   
                )
   66     60   
                .map_err(crate::operation::put_conformance_pack::PutConformancePackError::unhandled)?;
   67     61   
                let output = output.meta(generic);
   68     62   
                output.build()
   69     63   
            };
   70         -
            if tmp.message.is_none() {
   71         -
                tmp.message = _error_message;
   72         -
            }
   73     64   
            tmp
   74     65   
        }),
   75     66   
        "MaxNumberOfConformancePacksExceededException" => {
   76     67   
            crate::operation::put_conformance_pack::PutConformancePackError::MaxNumberOfConformancePacksExceededException({
   77     68   
                #[allow(unused_mut)]
   78     69   
                let mut tmp = {
   79     70   
                    #[allow(unused_mut)]
   80     71   
                    let mut output = crate::types::error::builders::MaxNumberOfConformancePacksExceededExceptionBuilder::default();
   81     72   
                    output = crate::protocol_serde::shape_max_number_of_conformance_packs_exceeded_exception::de_max_number_of_conformance_packs_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::put_conformance_pack::PutConformancePackError::unhandled)?;
   82     73   
                    let output = output.meta(generic);
   83     74   
                    output.build()
   84     75   
                };
   85         -
                if tmp.message.is_none() {
   86         -
                    tmp.message = _error_message;
   87         -
                }
   88     76   
                tmp
   89     77   
            })
   90     78   
        }
   91     79   
        "ResourceInUseException" => crate::operation::put_conformance_pack::PutConformancePackError::ResourceInUseException({
   92     80   
            #[allow(unused_mut)]
   93     81   
            let mut tmp = {
   94     82   
                #[allow(unused_mut)]
   95     83   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   96     84   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   97     85   
                    .map_err(crate::operation::put_conformance_pack::PutConformancePackError::unhandled)?;
   98     86   
                let output = output.meta(generic);
   99     87   
                output.build()
  100     88   
            };
  101         -
            if tmp.message.is_none() {
  102         -
                tmp.message = _error_message;
  103         -
            }
  104     89   
            tmp
  105     90   
        }),
  106     91   
        _ => crate::operation::put_conformance_pack::PutConformancePackError::generic(generic),
  107     92   
    })
  108     93   
}
  109     94   
  110     95   
#[allow(clippy::unnecessary_wraps)]
  111     96   
pub fn de_put_conformance_pack_http_response(
  112     97   
    _response_status: u16,
  113     98   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +188,164 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InsufficientDeliveryPolicyExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_insufficient_delivery_policy_exception::de_insufficient_delivery_policy_exception_json_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::put_delivery_channel::PutDeliveryChannelError::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   
        "InvalidDeliveryChannelNameException" => {
   44     41   
            crate::operation::put_delivery_channel::PutDeliveryChannelError::InvalidDeliveryChannelNameException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::InvalidDeliveryChannelNameExceptionBuilder::default();
   49     46   
                    output =
   50     47   
                        crate::protocol_serde::shape_invalid_delivery_channel_name_exception::de_invalid_delivery_channel_name_exception_json_err(
   51     48   
                            _response_body,
   52     49   
                            output,
   53     50   
                        )
   54     51   
                        .map_err(crate::operation::put_delivery_channel::PutDeliveryChannelError::unhandled)?;
   55     52   
                    let output = output.meta(generic);
   56     53   
                    output.build()
   57     54   
                };
   58         -
                if tmp.message.is_none() {
   59         -
                    tmp.message = _error_message;
   60         -
                }
   61     55   
                tmp
   62     56   
            })
   63     57   
        }
   64     58   
        "InvalidS3KeyPrefixException" => crate::operation::put_delivery_channel::PutDeliveryChannelError::InvalidS3KeyPrefixException({
   65     59   
            #[allow(unused_mut)]
   66     60   
            let mut tmp = {
   67     61   
                #[allow(unused_mut)]
   68     62   
                let mut output = crate::types::error::builders::InvalidS3KeyPrefixExceptionBuilder::default();
   69     63   
                output =
   70     64   
                    crate::protocol_serde::shape_invalid_s3_key_prefix_exception::de_invalid_s3_key_prefix_exception_json_err(_response_body, output)
   71     65   
                        .map_err(crate::operation::put_delivery_channel::PutDeliveryChannelError::unhandled)?;
   72     66   
                let output = output.meta(generic);
   73     67   
                output.build()
   74     68   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     69   
            tmp
   79     70   
        }),
   80     71   
        "InvalidS3KmsKeyArnException" => crate::operation::put_delivery_channel::PutDeliveryChannelError::InvalidS3KmsKeyArnException({
   81     72   
            #[allow(unused_mut)]
   82     73   
            let mut tmp = {
   83     74   
                #[allow(unused_mut)]
   84     75   
                let mut output = crate::types::error::builders::InvalidS3KmsKeyArnExceptionBuilder::default();
   85     76   
                output = crate::protocol_serde::shape_invalid_s3_kms_key_arn_exception::de_invalid_s3_kms_key_arn_exception_json_err(
   86     77   
                    _response_body,
   87     78   
                    output,
   88     79   
                )
   89     80   
                .map_err(crate::operation::put_delivery_channel::PutDeliveryChannelError::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   
        "InvalidSNSTopicARNException" => crate::operation::put_delivery_channel::PutDeliveryChannelError::InvalidSnsTopicArnException({
   99     87   
            #[allow(unused_mut)]
  100     88   
            let mut tmp = {
  101     89   
                #[allow(unused_mut)]
  102     90   
                let mut output = crate::types::error::builders::InvalidSnsTopicArnExceptionBuilder::default();
  103     91   
                output =
  104     92   
                    crate::protocol_serde::shape_invalid_sns_topic_arn_exception::de_invalid_sns_topic_arn_exception_json_err(_response_body, output)
  105     93   
                        .map_err(crate::operation::put_delivery_channel::PutDeliveryChannelError::unhandled)?;
  106     94   
                let output = output.meta(generic);
  107     95   
                output.build()
  108     96   
            };
  109         -
            if tmp.message.is_none() {
  110         -
                tmp.message = _error_message;
  111         -
            }
  112     97   
            tmp
  113     98   
        }),
  114     99   
        "MaxNumberOfDeliveryChannelsExceededException" => {
  115    100   
            crate::operation::put_delivery_channel::PutDeliveryChannelError::MaxNumberOfDeliveryChannelsExceededException({
  116    101   
                #[allow(unused_mut)]
  117    102   
                let mut tmp = {
  118    103   
                    #[allow(unused_mut)]
  119    104   
                    let mut output = crate::types::error::builders::MaxNumberOfDeliveryChannelsExceededExceptionBuilder::default();
  120    105   
                    output = crate::protocol_serde::shape_max_number_of_delivery_channels_exceeded_exception::de_max_number_of_delivery_channels_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::put_delivery_channel::PutDeliveryChannelError::unhandled)?;
  121    106   
                    let output = output.meta(generic);
  122    107   
                    output.build()
  123    108   
                };
  124         -
                if tmp.message.is_none() {
  125         -
                    tmp.message = _error_message;
  126         -
                }
  127    109   
                tmp
  128    110   
            })
  129    111   
        }
  130    112   
        "NoAvailableConfigurationRecorderException" => {
  131    113   
            crate::operation::put_delivery_channel::PutDeliveryChannelError::NoAvailableConfigurationRecorderException({
  132    114   
                #[allow(unused_mut)]
  133    115   
                let mut tmp = {
  134    116   
                    #[allow(unused_mut)]
  135    117   
                    let mut output = crate::types::error::builders::NoAvailableConfigurationRecorderExceptionBuilder::default();
  136    118   
                    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::put_delivery_channel::PutDeliveryChannelError::unhandled)?;
  137    119   
                    let output = output.meta(generic);
  138    120   
                    output.build()
  139    121   
                };
  140         -
                if tmp.message.is_none() {
  141         -
                    tmp.message = _error_message;
  142         -
                }
  143    122   
                tmp
  144    123   
            })
  145    124   
        }
  146    125   
        "NoSuchBucketException" => crate::operation::put_delivery_channel::PutDeliveryChannelError::NoSuchBucketException({
  147    126   
            #[allow(unused_mut)]
  148    127   
            let mut tmp = {
  149    128   
                #[allow(unused_mut)]
  150    129   
                let mut output = crate::types::error::builders::NoSuchBucketExceptionBuilder::default();
  151    130   
                output = crate::protocol_serde::shape_no_such_bucket_exception::de_no_such_bucket_exception_json_err(_response_body, output)
  152    131   
                    .map_err(crate::operation::put_delivery_channel::PutDeliveryChannelError::unhandled)?;
  153    132   
                let output = output.meta(generic);
  154    133   
                output.build()
  155    134   
            };
  156         -
            if tmp.message.is_none() {
  157         -
                tmp.message = _error_message;
  158         -
            }
  159    135   
            tmp
  160    136   
        }),
  161    137   
        _ => crate::operation::put_delivery_channel::PutDeliveryChannelError::generic(generic),
  162    138   
    })
  163    139   
}
  164    140   
  165    141   
#[allow(clippy::unnecessary_wraps)]
  166    142   
pub fn de_put_delivery_channel_http_response(
  167    143   
    _response_status: u16,
  168    144   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

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

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

@@ -6,6 +84,78 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::put_external_evaluation::PutExternalEvaluationError::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   
        "NoSuchConfigRuleException" => crate::operation::put_external_evaluation::PutExternalEvaluationError::NoSuchConfigRuleException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::NoSuchConfigRuleExceptionBuilder::default();
   46     43   
                output =
   47     44   
                    crate::protocol_serde::shape_no_such_config_rule_exception::de_no_such_config_rule_exception_json_err(_response_body, output)
   48     45   
                        .map_err(crate::operation::put_external_evaluation::PutExternalEvaluationError::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::put_external_evaluation::PutExternalEvaluationError::generic(generic),
   58     52   
    })
   59     53   
}
   60     54   
   61     55   
#[allow(clippy::unnecessary_wraps)]
   62     56   
pub fn de_put_external_evaluation_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_put_organization_config_rule.rs

@@ -11,11 +196,172 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InsufficientPermissionsExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_insufficient_permissions_exception::de_insufficient_permissions_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::unhandled)?;
   38     38   
                    let output = output.meta(generic);
   39     39   
                    output.build()
   40     40   
                };
   41         -
                if tmp.message.is_none() {
   42         -
                    tmp.message = _error_message;
   43         -
                }
   44     41   
                tmp
   45     42   
            })
   46     43   
        }
   47     44   
        "InvalidParameterValueException" => {
   48     45   
            crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::InvalidParameterValueException({
   49     46   
                #[allow(unused_mut)]
   50     47   
                let mut tmp = {
   51     48   
                    #[allow(unused_mut)]
   52     49   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   53     50   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   54     51   
                        _response_body,
   55     52   
                        output,
   56     53   
                    )
   57     54   
                    .map_err(crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::unhandled)?;
   58     55   
                    let output = output.meta(generic);
   59     56   
                    output.build()
   60     57   
                };
   61         -
                if tmp.message.is_none() {
   62         -
                    tmp.message = _error_message;
   63         -
                }
   64     58   
                tmp
   65     59   
            })
   66     60   
        }
   67     61   
        "MaxNumberOfOrganizationConfigRulesExceededException" => {
   68     62   
            crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::MaxNumberOfOrganizationConfigRulesExceededException({
   69     63   
                #[allow(unused_mut)]
   70     64   
                let mut tmp = {
   71     65   
                    #[allow(unused_mut)]
   72     66   
                    let mut output = crate::types::error::builders::MaxNumberOfOrganizationConfigRulesExceededExceptionBuilder::default();
   73     67   
                    output = crate::protocol_serde::shape_max_number_of_organization_config_rules_exceeded_exception::de_max_number_of_organization_config_rules_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::unhandled)?;
   74     68   
                    let output = output.meta(generic);
   75     69   
                    output.build()
   76     70   
                };
   77         -
                if tmp.message.is_none() {
   78         -
                    tmp.message = _error_message;
   79         -
                }
   80     71   
                tmp
   81     72   
            })
   82     73   
        }
   83     74   
        "NoAvailableOrganizationException" => {
   84     75   
            crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::NoAvailableOrganizationException({
   85     76   
                #[allow(unused_mut)]
   86     77   
                let mut tmp = {
   87     78   
                    #[allow(unused_mut)]
   88     79   
                    let mut output = crate::types::error::builders::NoAvailableOrganizationExceptionBuilder::default();
   89     80   
                    output = crate::protocol_serde::shape_no_available_organization_exception::de_no_available_organization_exception_json_err(
   90     81   
                        _response_body,
   91     82   
                        output,
   92     83   
                    )
   93     84   
                    .map_err(crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::unhandled)?;
   94     85   
                    let output = output.meta(generic);
   95     86   
                    output.build()
   96     87   
                };
   97         -
                if tmp.message.is_none() {
   98         -
                    tmp.message = _error_message;
   99         -
                }
  100     88   
                tmp
  101     89   
            })
  102     90   
        }
  103     91   
        "OrganizationAccessDeniedException" => {
  104     92   
            crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::OrganizationAccessDeniedException({
  105     93   
                #[allow(unused_mut)]
  106     94   
                let mut tmp = {
  107     95   
                    #[allow(unused_mut)]
  108     96   
                    let mut output = crate::types::error::builders::OrganizationAccessDeniedExceptionBuilder::default();
  109     97   
                    output = crate::protocol_serde::shape_organization_access_denied_exception::de_organization_access_denied_exception_json_err(
  110     98   
                        _response_body,
  111     99   
                        output,
  112    100   
                    )
  113    101   
                    .map_err(crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::unhandled)?;
  114    102   
                    let output = output.meta(generic);
  115    103   
                    output.build()
  116    104   
                };
  117         -
                if tmp.message.is_none() {
  118         -
                    tmp.message = _error_message;
  119         -
                }
  120    105   
                tmp
  121    106   
            })
  122    107   
        }
  123    108   
        "OrganizationAllFeaturesNotEnabledException" => {
  124    109   
            crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::OrganizationAllFeaturesNotEnabledException({
  125    110   
                #[allow(unused_mut)]
  126    111   
                let mut tmp = {
  127    112   
                    #[allow(unused_mut)]
  128    113   
                    let mut output = crate::types::error::builders::OrganizationAllFeaturesNotEnabledExceptionBuilder::default();
  129    114   
                    output = crate::protocol_serde::shape_organization_all_features_not_enabled_exception::de_organization_all_features_not_enabled_exception_json_err(_response_body, output).map_err(crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::unhandled)?;
  130    115   
                    let output = output.meta(generic);
  131    116   
                    output.build()
  132    117   
                };
  133         -
                if tmp.message.is_none() {
  134         -
                    tmp.message = _error_message;
  135         -
                }
  136    118   
                tmp
  137    119   
            })
  138    120   
        }
  139    121   
        "ResourceInUseException" => crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::ResourceInUseException({
  140    122   
            #[allow(unused_mut)]
  141    123   
            let mut tmp = {
  142    124   
                #[allow(unused_mut)]
  143    125   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
  144    126   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
  145    127   
                    .map_err(crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::unhandled)?;
  146    128   
                let output = output.meta(generic);
  147    129   
                output.build()
  148    130   
            };
  149         -
            if tmp.message.is_none() {
  150         -
                tmp.message = _error_message;
  151         -
            }
  152    131   
            tmp
  153    132   
        }),
  154    133   
        "ValidationException" => crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::ValidationException({
  155    134   
            #[allow(unused_mut)]
  156    135   
            let mut tmp = {
  157    136   
                #[allow(unused_mut)]
  158    137   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
  159    138   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  160    139   
                    .map_err(crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::unhandled)?;
  161    140   
                let output = output.meta(generic);
  162    141   
                output.build()
  163    142   
            };
  164         -
            if tmp.message.is_none() {
  165         -
                tmp.message = _error_message;
  166         -
            }
  167    143   
            tmp
  168    144   
        }),
  169    145   
        _ => crate::operation::put_organization_config_rule::PutOrganizationConfigRuleError::generic(generic),
  170    146   
    })
  171    147   
}
  172    148   
  173    149   
#[allow(clippy::unnecessary_wraps)]
  174    150   
pub fn de_put_organization_config_rule_http_response(
  175    151   
    _response_status: u16,
  176    152   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -4,4 +178,154 @@
   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::InsufficientPermissionsExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_insufficient_permissions_exception::de_insufficient_permissions_exception_json_err(_response_body, output).map_err(crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::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   
        "MaxNumberOfOrganizationConformancePacksExceededException" => crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::MaxNumberOfOrganizationConformancePacksExceededException({
   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::MaxNumberOfOrganizationConformancePacksExceededExceptionBuilder::default();
   45     42   
                    output = crate::protocol_serde::shape_max_number_of_organization_conformance_packs_exceeded_exception::de_max_number_of_organization_conformance_packs_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::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   
        "NoAvailableOrganizationException" => crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::NoAvailableOrganizationException({
   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::NoAvailableOrganizationExceptionBuilder::default();
   61     55   
                    output = crate::protocol_serde::shape_no_available_organization_exception::de_no_available_organization_exception_json_err(_response_body, output).map_err(crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::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::put_organization_conformance_pack::PutOrganizationConformancePackError::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::put_organization_conformance_pack::PutOrganizationConformancePackError::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   
        "OrganizationAllFeaturesNotEnabledException" => crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::OrganizationAllFeaturesNotEnabledException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp =
   90     78   
                 {
   91     79   
                    #[allow(unused_mut)]
   92     80   
                    let mut output = crate::types::error::builders::OrganizationAllFeaturesNotEnabledExceptionBuilder::default();
   93     81   
                    output = crate::protocol_serde::shape_organization_all_features_not_enabled_exception::de_organization_all_features_not_enabled_exception_json_err(_response_body, output).map_err(crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::unhandled)?;
   94     82   
                    let output = output.meta(generic);
   95     83   
                    output.build()
   96     84   
                }
   97     85   
            ;
   98         -
            if tmp.message.is_none() {
   99         -
                                                            tmp.message = _error_message;
  100         -
                                                        }
  101     86   
            tmp
  102     87   
        }),
  103     88   
        "OrganizationConformancePackTemplateValidationException" => crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::OrganizationConformancePackTemplateValidationException({
  104     89   
            #[allow(unused_mut)]
  105     90   
            let mut tmp =
  106     91   
                 {
  107     92   
                    #[allow(unused_mut)]
  108     93   
                    let mut output = crate::types::error::builders::OrganizationConformancePackTemplateValidationExceptionBuilder::default();
  109     94   
                    output = crate::protocol_serde::shape_organization_conformance_pack_template_validation_exception::de_organization_conformance_pack_template_validation_exception_json_err(_response_body, output).map_err(crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::unhandled)?;
  110     95   
                    let output = output.meta(generic);
  111     96   
                    output.build()
  112     97   
                }
  113     98   
            ;
  114         -
            if tmp.message.is_none() {
  115         -
                                                            tmp.message = _error_message;
  116         -
                                                        }
  117     99   
            tmp
  118    100   
        }),
  119    101   
        "ResourceInUseException" => crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::ResourceInUseException({
  120    102   
            #[allow(unused_mut)]
  121    103   
            let mut tmp =
  122    104   
                 {
  123    105   
                    #[allow(unused_mut)]
  124    106   
                    let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
  125    107   
                    output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output).map_err(crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::unhandled)?;
  126    108   
                    let output = output.meta(generic);
  127    109   
                    output.build()
  128    110   
                }
  129    111   
            ;
  130         -
            if tmp.message.is_none() {
  131         -
                                                            tmp.message = _error_message;
  132         -
                                                        }
  133    112   
            tmp
  134    113   
        }),
  135    114   
        "ValidationException" => crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::ValidationException({
  136    115   
            #[allow(unused_mut)]
  137    116   
            let mut tmp =
  138    117   
                 {
  139    118   
                    #[allow(unused_mut)]
  140    119   
                    let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
  141    120   
                    output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output).map_err(crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::unhandled)?;
  142    121   
                    let output = output.meta(generic);
  143    122   
                    output.build()
  144    123   
                }
  145    124   
            ;
  146         -
            if tmp.message.is_none() {
  147         -
                                                            tmp.message = _error_message;
  148         -
                                                        }
  149    125   
            tmp
  150    126   
        }),
  151    127   
        _ => crate::operation::put_organization_conformance_pack::PutOrganizationConformancePackError::generic(generic)
  152    128   
    })
  153    129   
}
  154    130   
  155    131   
#[allow(clippy::unnecessary_wraps)]
  156    132   
pub fn de_put_organization_conformance_pack_http_response(
  157    133   
    _response_status: u16,
  158    134   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +89,83 @@
   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::put_remediation_configurations::PutRemediationConfigurationsError::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::put_remediation_configurations::PutRemediationConfigurationsError::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::put_remediation_configurations::PutRemediationConfigurationsError::unhandled)?;
   54     51   
                    let output = output.meta(generic);
   55     52   
                    output.build()
   56     53   
                };
   57         -
                if tmp.message.is_none() {
   58         -
                    tmp.message = _error_message;
   59         -
                }
   60     54   
                tmp
   61     55   
            })
   62     56   
        }
   63     57   
        _ => crate::operation::put_remediation_configurations::PutRemediationConfigurationsError::generic(generic),
   64     58   
    })
   65     59   
}
   66     60   
   67     61   
#[allow(clippy::unnecessary_wraps)]
   68     62   
pub fn de_put_remediation_configurations_http_response(
   69     63   
    _response_status: u16,

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

@@ -11,11 +93,87 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InsufficientPermissionsExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_insufficient_permissions_exception::de_insufficient_permissions_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::put_remediation_exceptions::PutRemediationExceptionsError::unhandled)?;
   38     38   
                    let output = output.meta(generic);
   39     39   
                    output.build()
   40     40   
                };
   41         -
                if tmp.message.is_none() {
   42         -
                    tmp.message = _error_message;
   43         -
                }
   44     41   
                tmp
   45     42   
            })
   46     43   
        }
   47     44   
        "InvalidParameterValueException" => {
   48     45   
            crate::operation::put_remediation_exceptions::PutRemediationExceptionsError::InvalidParameterValueException({
   49     46   
                #[allow(unused_mut)]
   50     47   
                let mut tmp = {
   51     48   
                    #[allow(unused_mut)]
   52     49   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   53     50   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   54     51   
                        _response_body,
   55     52   
                        output,
   56     53   
                    )
   57     54   
                    .map_err(crate::operation::put_remediation_exceptions::PutRemediationExceptionsError::unhandled)?;
   58     55   
                    let output = output.meta(generic);
   59     56   
                    output.build()
   60     57   
                };
   61         -
                if tmp.message.is_none() {
   62         -
                    tmp.message = _error_message;
   63         -
                }
   64     58   
                tmp
   65     59   
            })
   66     60   
        }
   67     61   
        _ => crate::operation::put_remediation_exceptions::PutRemediationExceptionsError::generic(generic),
   68     62   
    })
   69     63   
}
   70     64   
   71     65   
#[allow(clippy::unnecessary_wraps)]
   72     66   
pub fn de_put_remediation_exceptions_http_response(
   73     67   
    _response_status: u16,

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

@@ -4,4 +118,106 @@
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::InsufficientPermissionsExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_insufficient_permissions_exception::de_insufficient_permissions_exception_json_err(
   27     27   
                    _response_body,
   28     28   
                    output,
   29     29   
                )
   30     30   
                .map_err(crate::operation::put_resource_config::PutResourceConfigError::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   
        "MaxActiveResourcesExceededException" => {
   40     37   
            crate::operation::put_resource_config::PutResourceConfigError::MaxActiveResourcesExceededException({
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut tmp = {
   43     40   
                    #[allow(unused_mut)]
   44     41   
                    let mut output = crate::types::error::builders::MaxActiveResourcesExceededExceptionBuilder::default();
   45     42   
                    output =
   46     43   
                        crate::protocol_serde::shape_max_active_resources_exceeded_exception::de_max_active_resources_exceeded_exception_json_err(
   47     44   
                            _response_body,
   48     45   
                            output,
   49     46   
                        )
   50     47   
                        .map_err(crate::operation::put_resource_config::PutResourceConfigError::unhandled)?;
   51     48   
                    let output = output.meta(generic);
   52     49   
                    output.build()
   53     50   
                };
   54         -
                if tmp.message.is_none() {
   55         -
                    tmp.message = _error_message;
   56         -
                }
   57     51   
                tmp
   58     52   
            })
   59     53   
        }
   60     54   
        "NoRunningConfigurationRecorderException" => {
   61     55   
            crate::operation::put_resource_config::PutResourceConfigError::NoRunningConfigurationRecorderException({
   62     56   
                #[allow(unused_mut)]
   63     57   
                let mut tmp = {
   64     58   
                    #[allow(unused_mut)]
   65     59   
                    let mut output = crate::types::error::builders::NoRunningConfigurationRecorderExceptionBuilder::default();
   66     60   
                    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::put_resource_config::PutResourceConfigError::unhandled)?;
   67     61   
                    let output = output.meta(generic);
   68     62   
                    output.build()
   69     63   
                };
   70         -
                if tmp.message.is_none() {
   71         -
                    tmp.message = _error_message;
   72         -
                }
   73     64   
                tmp
   74     65   
            })
   75     66   
        }
   76     67   
        "ValidationException" => crate::operation::put_resource_config::PutResourceConfigError::ValidationException({
   77     68   
            #[allow(unused_mut)]
   78     69   
            let mut tmp = {
   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)
   82     73   
                    .map_err(crate::operation::put_resource_config::PutResourceConfigError::unhandled)?;
   83     74   
                let output = output.meta(generic);
   84     75   
                output.build()
   85     76   
            };
   86         -
            if tmp.message.is_none() {
   87         -
                tmp.message = _error_message;
   88         -
            }
   89     77   
            tmp
   90     78   
        }),
   91     79   
        _ => crate::operation::put_resource_config::PutResourceConfigError::generic(generic),
   92     80   
    })
   93     81   
}
   94     82   
   95     83   
#[allow(clippy::unnecessary_wraps)]
   96     84   
pub fn de_put_resource_config_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_put_retention_configuration.rs

@@ -11,11 +89,83 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::put_retention_configuration::PutRetentionConfigurationError::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   
        "MaxNumberOfRetentionConfigurationsExceededException" => {
   48     45   
            crate::operation::put_retention_configuration::PutRetentionConfigurationError::MaxNumberOfRetentionConfigurationsExceededException({
   49     46   
                #[allow(unused_mut)]
   50     47   
                let mut tmp = {
   51     48   
                    #[allow(unused_mut)]
   52     49   
                    let mut output = crate::types::error::builders::MaxNumberOfRetentionConfigurationsExceededExceptionBuilder::default();
   53     50   
                    output = crate::protocol_serde::shape_max_number_of_retention_configurations_exceeded_exception::de_max_number_of_retention_configurations_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::put_retention_configuration::PutRetentionConfigurationError::unhandled)?;
   54     51   
                    let output = output.meta(generic);
   55     52   
                    output.build()
   56     53   
                };
   57         -
                if tmp.message.is_none() {
   58         -
                    tmp.message = _error_message;
   59         -
                }
   60     54   
                tmp
   61     55   
            })
   62     56   
        }
   63     57   
        _ => crate::operation::put_retention_configuration::PutRetentionConfigurationError::generic(generic),
   64     58   
    })
   65     59   
}
   66     60   
   67     61   
#[allow(clippy::unnecessary_wraps)]
   68     62   
pub fn de_put_retention_configuration_http_response(
   69     63   
    _response_status: u16,