AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05

Files changed:

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_remove_role_from_instance_profile.rs

@@ -3,3 +105,93 @@
   23     23   
        "LimitExceeded" => crate::operation::remove_role_from_instance_profile::RemoveRoleFromInstanceProfileError::LimitExceededException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::remove_role_from_instance_profile::RemoveRoleFromInstanceProfileError::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   
        "NoSuchEntity" => crate::operation::remove_role_from_instance_profile::RemoveRoleFromInstanceProfileError::NoSuchEntityException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::remove_role_from_instance_profile::RemoveRoleFromInstanceProfileError::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   
        "ServiceFailure" => crate::operation::remove_role_from_instance_profile::RemoveRoleFromInstanceProfileError::ServiceFailureException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::remove_role_from_instance_profile::RemoveRoleFromInstanceProfileError::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   
        "UnmodifiableEntity" => {
   69     60   
            crate::operation::remove_role_from_instance_profile::RemoveRoleFromInstanceProfileError::UnmodifiableEntityException({
   70     61   
                #[allow(unused_mut)]
   71     62   
                let mut tmp = {
   72     63   
                    #[allow(unused_mut)]
   73     64   
                    let mut output = crate::types::error::builders::UnmodifiableEntityExceptionBuilder::default();
   74     65   
                    output =
   75     66   
                        crate::protocol_serde::shape_unmodifiable_entity_exception::de_unmodifiable_entity_exception_xml_err(_response_body, output)
   76     67   
                            .map_err(crate::operation::remove_role_from_instance_profile::RemoveRoleFromInstanceProfileError::unhandled)?;
   77     68   
                    let output = output.meta(generic);
   78     69   
                    output.build()
   79     70   
                };
   80         -
                if tmp.message.is_none() {
   81         -
                    tmp.message = _error_message;
   82         -
                }
   83     71   
                tmp
   84     72   
            })
   85     73   
        }
   86     74   
        _ => crate::operation::remove_role_from_instance_profile::RemoveRoleFromInstanceProfileError::generic(generic),
   87     75   
    })
   88     76   
}
   89     77   
   90     78   
#[allow(clippy::unnecessary_wraps)]
   91     79   
pub fn de_remove_role_from_instance_profile_http_response(
   92     80   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_remove_user_from_group.rs

@@ -3,3 +87,78 @@
   23     23   
        "LimitExceeded" => crate::operation::remove_user_from_group::RemoveUserFromGroupError::LimitExceededException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::remove_user_from_group::RemoveUserFromGroupError::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   
        "NoSuchEntity" => crate::operation::remove_user_from_group::RemoveUserFromGroupError::NoSuchEntityException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::remove_user_from_group::RemoveUserFromGroupError::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   
        "ServiceFailure" => crate::operation::remove_user_from_group::RemoveUserFromGroupError::ServiceFailureException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::remove_user_from_group::RemoveUserFromGroupError::unhandled)?;
   60     54   
                let output = output.meta(generic);
   61     55   
                output.build()
   62     56   
            };
   63         -
            if tmp.message.is_none() {
   64         -
                tmp.message = _error_message;
   65         -
            }
   66     57   
            tmp
   67     58   
        }),
   68     59   
        _ => crate::operation::remove_user_from_group::RemoveUserFromGroupError::generic(generic),
   69     60   
    })
   70     61   
}
   71     62   
   72     63   
#[allow(clippy::unnecessary_wraps)]
   73     64   
pub fn de_remove_user_from_group_http_response(
   74     65   
    _response_status: u16,
   75     66   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_reset_service_specific_credential.rs

@@ -3,3 +65,62 @@
   23     23   
        "NoSuchEntity" => crate::operation::reset_service_specific_credential::ResetServiceSpecificCredentialError::NoSuchEntityException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::reset_service_specific_credential::ResetServiceSpecificCredentialError::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   
        _ => crate::operation::reset_service_specific_credential::ResetServiceSpecificCredentialError::generic(generic),
   39     36   
    })
   40     37   
}
   41     38   
   42     39   
#[allow(clippy::unnecessary_wraps)]
   43     40   
pub fn de_reset_service_specific_credential_http_response(
   44     41   
    _response_status: u16,
   45     42   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_resync_mfa_device.rs

@@ -3,3 +117,102 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ConcurrentModificationExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_concurrent_modification_exception::de_concurrent_modification_exception_xml_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::resync_mfa_device::ResyncMFADeviceError::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   
        "InvalidAuthenticationCode" => crate::operation::resync_mfa_device::ResyncMFADeviceError::InvalidAuthenticationCodeException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidAuthenticationCodeExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_authentication_code_exception::de_invalid_authentication_code_exception_xml_err(
   44     41   
                    _response_body,
   45     42   
                    output,
   46     43   
                )
   47     44   
                .map_err(crate::operation::resync_mfa_device::ResyncMFADeviceError::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   
        "LimitExceeded" => crate::operation::resync_mfa_device::ResyncMFADeviceError::LimitExceededException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::resync_mfa_device::ResyncMFADeviceError::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   
        "NoSuchEntity" => crate::operation::resync_mfa_device::ResyncMFADeviceError::NoSuchEntityException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::resync_mfa_device::ResyncMFADeviceError::unhandled)?;
   78     69   
                let output = output.meta(generic);
   79     70   
                output.build()
   80     71   
            };
   81         -
            if tmp.message.is_none() {
   82         -
                tmp.message = _error_message;
   83         -
            }
   84     72   
            tmp
   85     73   
        }),
   86     74   
        "ServiceFailure" => crate::operation::resync_mfa_device::ResyncMFADeviceError::ServiceFailureException({
   87     75   
            #[allow(unused_mut)]
   88     76   
            let mut tmp = {
   89     77   
                #[allow(unused_mut)]
   90     78   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   91     79   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   92     80   
                    .map_err(crate::operation::resync_mfa_device::ResyncMFADeviceError::unhandled)?;
   93     81   
                let output = output.meta(generic);
   94     82   
                output.build()
   95     83   
            };
   96         -
            if tmp.message.is_none() {
   97         -
                tmp.message = _error_message;
   98         -
            }
   99     84   
            tmp
  100     85   
        }),
  101     86   
        _ => crate::operation::resync_mfa_device::ResyncMFADeviceError::generic(generic),
  102     87   
    })
  103     88   
}
  104     89   
  105     90   
#[allow(clippy::unnecessary_wraps)]
  106     91   
pub fn de_resync_mfa_device_http_response(
  107     92   
    _response_status: u16,
  108     93   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_set_default_policy_version.rs

@@ -7,7 +106,94 @@
   27     27   
        "InvalidInput" => crate::operation::set_default_policy_version::SetDefaultPolicyVersionError::InvalidInputException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::set_default_policy_version::SetDefaultPolicyVersionError::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   
        "LimitExceeded" => crate::operation::set_default_policy_version::SetDefaultPolicyVersionError::LimitExceededException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::set_default_policy_version::SetDefaultPolicyVersionError::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   
        "NoSuchEntity" => crate::operation::set_default_policy_version::SetDefaultPolicyVersionError::NoSuchEntityException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::set_default_policy_version::SetDefaultPolicyVersionError::unhandled)?;
   64     58   
                let output = output.meta(generic);
   65     59   
                output.build()
   66     60   
            };
   67         -
            if tmp.message.is_none() {
   68         -
                tmp.message = _error_message;
   69         -
            }
   70     61   
            tmp
   71     62   
        }),
   72     63   
        "ServiceFailure" => crate::operation::set_default_policy_version::SetDefaultPolicyVersionError::ServiceFailureException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::set_default_policy_version::SetDefaultPolicyVersionError::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   
        _ => crate::operation::set_default_policy_version::SetDefaultPolicyVersionError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_set_default_policy_version_http_response(
   93     81   
    _response_status: u16,
   94     82   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_set_security_token_service_preferences.rs

@@ -4,4 +60,57 @@
   24     24   
            crate::operation::set_security_token_service_preferences::SetSecurityTokenServicePreferencesError::ServiceFailureException({
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   30     30   
                        .map_err(crate::operation::set_security_token_service_preferences::SetSecurityTokenServicePreferencesError::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   
        _ => crate::operation::set_security_token_service_preferences::SetSecurityTokenServicePreferencesError::generic(generic),
   41     38   
    })
   42     39   
}
   43     40   
   44     41   
#[allow(clippy::unnecessary_wraps)]
   45     42   
pub fn de_set_security_token_service_preferences_http_response(
   46     43   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_simulate_custom_policy.rs

@@ -3,3 +80,74 @@
   23     23   
        "InvalidInput" => crate::operation::simulate_custom_policy::SimulateCustomPolicyError::InvalidInputException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::simulate_custom_policy::SimulateCustomPolicyError::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   
        "PolicyEvaluation" => crate::operation::simulate_custom_policy::SimulateCustomPolicyError::PolicyEvaluationException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::PolicyEvaluationExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_policy_evaluation_exception::de_policy_evaluation_exception_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::simulate_custom_policy::SimulateCustomPolicyError::unhandled)?;
   45     42   
                let output = output.meta(generic);
   46     43   
                output.build()
   47     44   
            };
   48         -
            if tmp.message.is_none() {
   49         -
                tmp.message = _error_message;
   50         -
            }
   51     45   
            tmp
   52     46   
        }),
   53     47   
        _ => crate::operation::simulate_custom_policy::SimulateCustomPolicyError::generic(generic),
   54     48   
    })
   55     49   
}
   56     50   
   57     51   
#[allow(clippy::unnecessary_wraps)]
   58     52   
pub fn de_simulate_custom_policy_http_response(
   59     53   
    _response_status: u16,
   60     54   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_simulate_principal_policy.rs

@@ -7,7 +99,90 @@
   27     27   
        "InvalidInput" => crate::operation::simulate_principal_policy::SimulatePrincipalPolicyError::InvalidInputException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::simulate_principal_policy::SimulatePrincipalPolicyError::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   
        "NoSuchEntity" => crate::operation::simulate_principal_policy::SimulatePrincipalPolicyError::NoSuchEntityException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::simulate_principal_policy::SimulatePrincipalPolicyError::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   
        "PolicyEvaluation" => crate::operation::simulate_principal_policy::SimulatePrincipalPolicyError::PolicyEvaluationException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::PolicyEvaluationExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_policy_evaluation_exception::de_policy_evaluation_exception_xml_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::simulate_principal_policy::SimulatePrincipalPolicyError::unhandled)?;
   64     58   
                let output = output.meta(generic);
   65     59   
                output.build()
   66     60   
            };
   67         -
            if tmp.message.is_none() {
   68         -
                tmp.message = _error_message;
   69         -
            }
   70     61   
            tmp
   71     62   
        }),
   72     63   
        _ => crate::operation::simulate_principal_policy::SimulatePrincipalPolicyError::generic(generic),
   73     64   
    })
   74     65   
}
   75     66   
   76     67   
#[allow(clippy::unnecessary_wraps)]
   77     68   
pub fn de_simulate_principal_policy_http_response(
   78     69   
    _response_status: u16,
   79     70   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_tag_instance_profile.rs

@@ -6,6 +120,105 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ConcurrentModificationExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_concurrent_modification_exception::de_concurrent_modification_exception_xml_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::tag_instance_profile::TagInstanceProfileError::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   
        "InvalidInput" => crate::operation::tag_instance_profile::TagInstanceProfileError::InvalidInputException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::tag_instance_profile::TagInstanceProfileError::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   
        "LimitExceeded" => crate::operation::tag_instance_profile::TagInstanceProfileError::LimitExceededException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::tag_instance_profile::TagInstanceProfileError::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   
        "NoSuchEntity" => crate::operation::tag_instance_profile::TagInstanceProfileError::NoSuchEntityException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::tag_instance_profile::TagInstanceProfileError::unhandled)?;
   78     69   
                let output = output.meta(generic);
   79     70   
                output.build()
   80     71   
            };
   81         -
            if tmp.message.is_none() {
   82         -
                tmp.message = _error_message;
   83         -
            }
   84     72   
            tmp
   85     73   
        }),
   86     74   
        "ServiceFailure" => crate::operation::tag_instance_profile::TagInstanceProfileError::ServiceFailureException({
   87     75   
            #[allow(unused_mut)]
   88     76   
            let mut tmp = {
   89     77   
                #[allow(unused_mut)]
   90     78   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   91     79   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   92     80   
                    .map_err(crate::operation::tag_instance_profile::TagInstanceProfileError::unhandled)?;
   93     81   
                let output = output.meta(generic);
   94     82   
                output.build()
   95     83   
            };
   96         -
            if tmp.message.is_none() {
   97         -
                tmp.message = _error_message;
   98         -
            }
   99     84   
            tmp
  100     85   
        }),
  101     86   
        _ => crate::operation::tag_instance_profile::TagInstanceProfileError::generic(generic),
  102     87   
    })
  103     88   
}
  104     89   
  105     90   
#[allow(clippy::unnecessary_wraps)]
  106     91   
pub fn de_tag_instance_profile_http_response(
  107     92   
    _response_status: u16,
  108     93   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_tag_mfa_device.rs

@@ -3,3 +114,99 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ConcurrentModificationExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_concurrent_modification_exception::de_concurrent_modification_exception_xml_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::tag_mfa_device::TagMFADeviceError::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   
        "InvalidInput" => crate::operation::tag_mfa_device::TagMFADeviceError::InvalidInputException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::tag_mfa_device::TagMFADeviceError::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   
        "LimitExceeded" => crate::operation::tag_mfa_device::TagMFADeviceError::LimitExceededException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::tag_mfa_device::TagMFADeviceError::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   
        "NoSuchEntity" => crate::operation::tag_mfa_device::TagMFADeviceError::NoSuchEntityException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::tag_mfa_device::TagMFADeviceError::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   
        "ServiceFailure" => crate::operation::tag_mfa_device::TagMFADeviceError::ServiceFailureException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::tag_mfa_device::TagMFADeviceError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        _ => crate::operation::tag_mfa_device::TagMFADeviceError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_tag_mfa_device_http_response(
  104     89   
    _response_status: u16,
  105     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_tag_open_id_connect_provider.rs

@@ -10,10 +124,109 @@
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::ConcurrentModificationExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_concurrent_modification_exception::de_concurrent_modification_exception_xml_err(
   33     33   
                    _response_body,
   34     34   
                    output,
   35     35   
                )
   36     36   
                .map_err(crate::operation::tag_open_id_connect_provider::TagOpenIDConnectProviderError::unhandled)?;
   37     37   
                let output = output.meta(generic);
   38     38   
                output.build()
   39     39   
            };
   40         -
            if tmp.message.is_none() {
   41         -
                tmp.message = _error_message;
   42         -
            }
   43     40   
            tmp
   44     41   
        }),
   45     42   
        "InvalidInput" => crate::operation::tag_open_id_connect_provider::TagOpenIDConnectProviderError::InvalidInputException({
   46     43   
            #[allow(unused_mut)]
   47     44   
            let mut tmp = {
   48     45   
                #[allow(unused_mut)]
   49     46   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   50     47   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   51     48   
                    .map_err(crate::operation::tag_open_id_connect_provider::TagOpenIDConnectProviderError::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   
        "LimitExceeded" => crate::operation::tag_open_id_connect_provider::TagOpenIDConnectProviderError::LimitExceededException({
   61     55   
            #[allow(unused_mut)]
   62     56   
            let mut tmp = {
   63     57   
                #[allow(unused_mut)]
   64     58   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   65     59   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   66     60   
                    .map_err(crate::operation::tag_open_id_connect_provider::TagOpenIDConnectProviderError::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   
        "NoSuchEntity" => crate::operation::tag_open_id_connect_provider::TagOpenIDConnectProviderError::NoSuchEntityException({
   76     67   
            #[allow(unused_mut)]
   77     68   
            let mut tmp = {
   78     69   
                #[allow(unused_mut)]
   79     70   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   80     71   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   81     72   
                    .map_err(crate::operation::tag_open_id_connect_provider::TagOpenIDConnectProviderError::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   
        "ServiceFailure" => crate::operation::tag_open_id_connect_provider::TagOpenIDConnectProviderError::ServiceFailureException({
   91     79   
            #[allow(unused_mut)]
   92     80   
            let mut tmp = {
   93     81   
                #[allow(unused_mut)]
   94     82   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   95     83   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   96     84   
                    .map_err(crate::operation::tag_open_id_connect_provider::TagOpenIDConnectProviderError::unhandled)?;
   97     85   
                let output = output.meta(generic);
   98     86   
                output.build()
   99     87   
            };
  100         -
            if tmp.message.is_none() {
  101         -
                tmp.message = _error_message;
  102         -
            }
  103     88   
            tmp
  104     89   
        }),
  105     90   
        _ => crate::operation::tag_open_id_connect_provider::TagOpenIDConnectProviderError::generic(generic),
  106     91   
    })
  107     92   
}
  108     93   
  109     94   
#[allow(clippy::unnecessary_wraps)]
  110     95   
pub fn de_tag_open_id_connect_provider_http_response(
  111     96   
    _response_status: u16,
  112     97   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_tag_policy.rs

@@ -3,3 +114,99 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ConcurrentModificationExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_concurrent_modification_exception::de_concurrent_modification_exception_xml_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::tag_policy::TagPolicyError::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   
        "InvalidInput" => crate::operation::tag_policy::TagPolicyError::InvalidInputException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::tag_policy::TagPolicyError::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   
        "LimitExceeded" => crate::operation::tag_policy::TagPolicyError::LimitExceededException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::tag_policy::TagPolicyError::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   
        "NoSuchEntity" => crate::operation::tag_policy::TagPolicyError::NoSuchEntityException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::tag_policy::TagPolicyError::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   
        "ServiceFailure" => crate::operation::tag_policy::TagPolicyError::ServiceFailureException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::tag_policy::TagPolicyError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        _ => crate::operation::tag_policy::TagPolicyError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_tag_policy_http_response(
  104     89   
    _response_status: u16,
  105     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_tag_role.rs

@@ -3,3 +114,99 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ConcurrentModificationExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_concurrent_modification_exception::de_concurrent_modification_exception_xml_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::tag_role::TagRoleError::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   
        "InvalidInput" => crate::operation::tag_role::TagRoleError::InvalidInputException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::tag_role::TagRoleError::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   
        "LimitExceeded" => crate::operation::tag_role::TagRoleError::LimitExceededException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::tag_role::TagRoleError::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   
        "NoSuchEntity" => crate::operation::tag_role::TagRoleError::NoSuchEntityException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::tag_role::TagRoleError::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   
        "ServiceFailure" => crate::operation::tag_role::TagRoleError::ServiceFailureException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::tag_role::TagRoleError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        _ => crate::operation::tag_role::TagRoleError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_tag_role_http_response(
  104     89   
    _response_status: u16,
  105     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_tag_saml_provider.rs

@@ -3,3 +114,99 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ConcurrentModificationExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_concurrent_modification_exception::de_concurrent_modification_exception_xml_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::tag_saml_provider::TagSAMLProviderError::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   
        "InvalidInput" => crate::operation::tag_saml_provider::TagSAMLProviderError::InvalidInputException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::tag_saml_provider::TagSAMLProviderError::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   
        "LimitExceeded" => crate::operation::tag_saml_provider::TagSAMLProviderError::LimitExceededException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::tag_saml_provider::TagSAMLProviderError::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   
        "NoSuchEntity" => crate::operation::tag_saml_provider::TagSAMLProviderError::NoSuchEntityException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::tag_saml_provider::TagSAMLProviderError::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   
        "ServiceFailure" => crate::operation::tag_saml_provider::TagSAMLProviderError::ServiceFailureException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::tag_saml_provider::TagSAMLProviderError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        _ => crate::operation::tag_saml_provider::TagSAMLProviderError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_tag_saml_provider_http_response(
  104     89   
    _response_status: u16,
  105     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_tag_server_certificate.rs

@@ -6,6 +120,105 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ConcurrentModificationExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_concurrent_modification_exception::de_concurrent_modification_exception_xml_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::tag_server_certificate::TagServerCertificateError::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   
        "InvalidInput" => crate::operation::tag_server_certificate::TagServerCertificateError::InvalidInputException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::tag_server_certificate::TagServerCertificateError::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   
        "LimitExceeded" => crate::operation::tag_server_certificate::TagServerCertificateError::LimitExceededException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::tag_server_certificate::TagServerCertificateError::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   
        "NoSuchEntity" => crate::operation::tag_server_certificate::TagServerCertificateError::NoSuchEntityException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::tag_server_certificate::TagServerCertificateError::unhandled)?;
   78     69   
                let output = output.meta(generic);
   79     70   
                output.build()
   80     71   
            };
   81         -
            if tmp.message.is_none() {
   82         -
                tmp.message = _error_message;
   83         -
            }
   84     72   
            tmp
   85     73   
        }),
   86     74   
        "ServiceFailure" => crate::operation::tag_server_certificate::TagServerCertificateError::ServiceFailureException({
   87     75   
            #[allow(unused_mut)]
   88     76   
            let mut tmp = {
   89     77   
                #[allow(unused_mut)]
   90     78   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   91     79   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   92     80   
                    .map_err(crate::operation::tag_server_certificate::TagServerCertificateError::unhandled)?;
   93     81   
                let output = output.meta(generic);
   94     82   
                output.build()
   95     83   
            };
   96         -
            if tmp.message.is_none() {
   97         -
                tmp.message = _error_message;
   98         -
            }
   99     84   
            tmp
  100     85   
        }),
  101     86   
        _ => crate::operation::tag_server_certificate::TagServerCertificateError::generic(generic),
  102     87   
    })
  103     88   
}
  104     89   
  105     90   
#[allow(clippy::unnecessary_wraps)]
  106     91   
pub fn de_tag_server_certificate_http_response(
  107     92   
    _response_status: u16,
  108     93   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/iam/src/protocol_serde/shape_tag_user.rs

@@ -3,3 +114,99 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ConcurrentModificationExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_concurrent_modification_exception::de_concurrent_modification_exception_xml_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::tag_user::TagUserError::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   
        "InvalidInput" => crate::operation::tag_user::TagUserError::InvalidInputException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::tag_user::TagUserError::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   
        "LimitExceeded" => crate::operation::tag_user::TagUserError::LimitExceededException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::tag_user::TagUserError::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   
        "NoSuchEntity" => crate::operation::tag_user::TagUserError::NoSuchEntityException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::tag_user::TagUserError::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   
        "ServiceFailure" => crate::operation::tag_user::TagUserError::ServiceFailureException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::tag_user::TagUserError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        _ => crate::operation::tag_user::TagUserError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_tag_user_http_response(
  104     89   
    _response_status: u16,
  105     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,