AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df (ignoring whitespace)

Files changed:

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

@@ -1,1 +127,109 @@
   20     20   
        "InvalidInput" => crate::operation::attach_role_policy::AttachRolePolicyError::InvalidInputException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::attach_role_policy::AttachRolePolicyError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "LimitExceeded" => crate::operation::attach_role_policy::AttachRolePolicyError::LimitExceededException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::attach_role_policy::AttachRolePolicyError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "NoSuchEntity" => crate::operation::attach_role_policy::AttachRolePolicyError::NoSuchEntityException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::attach_role_policy::AttachRolePolicyError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "PolicyNotAttachable" => crate::operation::attach_role_policy::AttachRolePolicyError::PolicyNotAttachableException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::PolicyNotAttachableExceptionBuilder::default();
   70     61   
                output =
   71     62   
                    crate::protocol_serde::shape_policy_not_attachable_exception::de_policy_not_attachable_exception_xml_err(_response_body, output)
   72     63   
                        .map_err(crate::operation::attach_role_policy::AttachRolePolicyError::unhandled)?;
   73     64   
                let output = output.meta(generic);
   74     65   
                output.build()
   75     66   
            };
   76         -
            if tmp.message.is_none() {
   77         -
                tmp.message = _error_message;
   78         -
            }
   79     67   
            tmp
   80     68   
        }),
   81     69   
        "ServiceFailure" => crate::operation::attach_role_policy::AttachRolePolicyError::ServiceFailureException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   87     75   
                    .map_err(crate::operation::attach_role_policy::AttachRolePolicyError::unhandled)?;
   88     76   
                let output = output.meta(generic);
   89     77   
                output.build()
   90     78   
            };
   91         -
            if tmp.message.is_none() {
   92         -
                tmp.message = _error_message;
   93         -
            }
   94     79   
            tmp
   95     80   
        }),
   96     81   
        "UnmodifiableEntity" => crate::operation::attach_role_policy::AttachRolePolicyError::UnmodifiableEntityException({
   97     82   
            #[allow(unused_mut)]
   98     83   
            let mut tmp = {
   99     84   
                #[allow(unused_mut)]
  100     85   
                let mut output = crate::types::error::builders::UnmodifiableEntityExceptionBuilder::default();
  101     86   
                output = crate::protocol_serde::shape_unmodifiable_entity_exception::de_unmodifiable_entity_exception_xml_err(_response_body, output)
  102     87   
                    .map_err(crate::operation::attach_role_policy::AttachRolePolicyError::unhandled)?;
  103     88   
                let output = output.meta(generic);
  104     89   
                output.build()
  105     90   
            };
  106         -
            if tmp.message.is_none() {
  107         -
                tmp.message = _error_message;
  108         -
            }
  109     91   
            tmp
  110     92   
        }),
  111     93   
        _ => crate::operation::attach_role_policy::AttachRolePolicyError::generic(generic),
  112     94   
    })
  113     95   
}
  114     96   
  115     97   
#[allow(clippy::unnecessary_wraps)]
  116     98   
pub fn de_attach_role_policy_http_response(
  117     99   
    _response_status: u16,
  118    100   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +112,97 @@
   20     20   
        "InvalidInput" => crate::operation::attach_user_policy::AttachUserPolicyError::InvalidInputException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::attach_user_policy::AttachUserPolicyError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "LimitExceeded" => crate::operation::attach_user_policy::AttachUserPolicyError::LimitExceededException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::attach_user_policy::AttachUserPolicyError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "NoSuchEntity" => crate::operation::attach_user_policy::AttachUserPolicyError::NoSuchEntityException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::attach_user_policy::AttachUserPolicyError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "PolicyNotAttachable" => crate::operation::attach_user_policy::AttachUserPolicyError::PolicyNotAttachableException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::PolicyNotAttachableExceptionBuilder::default();
   70     61   
                output =
   71     62   
                    crate::protocol_serde::shape_policy_not_attachable_exception::de_policy_not_attachable_exception_xml_err(_response_body, output)
   72     63   
                        .map_err(crate::operation::attach_user_policy::AttachUserPolicyError::unhandled)?;
   73     64   
                let output = output.meta(generic);
   74     65   
                output.build()
   75     66   
            };
   76         -
            if tmp.message.is_none() {
   77         -
                tmp.message = _error_message;
   78         -
            }
   79     67   
            tmp
   80     68   
        }),
   81     69   
        "ServiceFailure" => crate::operation::attach_user_policy::AttachUserPolicyError::ServiceFailureException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   87     75   
                    .map_err(crate::operation::attach_user_policy::AttachUserPolicyError::unhandled)?;
   88     76   
                let output = output.meta(generic);
   89     77   
                output.build()
   90     78   
            };
   91         -
            if tmp.message.is_none() {
   92         -
                tmp.message = _error_message;
   93         -
            }
   94     79   
            tmp
   95     80   
        }),
   96     81   
        _ => crate::operation::attach_user_policy::AttachUserPolicyError::generic(generic),
   97     82   
    })
   98     83   
}
   99     84   
  100     85   
#[allow(clippy::unnecessary_wraps)]
  101     86   
pub fn de_attach_user_policy_http_response(
  102     87   
    _response_status: u16,
  103     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -4,4 +133,115 @@
   24     24   
                let mut output = crate::types::error::builders::EntityTemporarilyUnmodifiableExceptionBuilder::default();
   25     25   
                output =
   26     26   
                    crate::protocol_serde::shape_entity_temporarily_unmodifiable_exception::de_entity_temporarily_unmodifiable_exception_xml_err(
   27     27   
                        _response_body,
   28     28   
                        output,
   29     29   
                    )
   30     30   
                    .map_err(crate::operation::change_password::ChangePasswordError::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   
        "InvalidUserType" => crate::operation::change_password::ChangePasswordError::InvalidUserTypeException({
   40     37   
            #[allow(unused_mut)]
   41     38   
            let mut tmp = {
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut output = crate::types::error::builders::InvalidUserTypeExceptionBuilder::default();
   44     41   
                output = crate::protocol_serde::shape_invalid_user_type_exception::de_invalid_user_type_exception_xml_err(_response_body, output)
   45     42   
                    .map_err(crate::operation::change_password::ChangePasswordError::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   
        "LimitExceeded" => crate::operation::change_password::ChangePasswordError::LimitExceededException({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   60     54   
                    .map_err(crate::operation::change_password::ChangePasswordError::unhandled)?;
   61     55   
                let output = output.meta(generic);
   62     56   
                output.build()
   63     57   
            };
   64         -
            if tmp.message.is_none() {
   65         -
                tmp.message = _error_message;
   66         -
            }
   67     58   
            tmp
   68     59   
        }),
   69     60   
        "NoSuchEntity" => crate::operation::change_password::ChangePasswordError::NoSuchEntityException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::change_password::ChangePasswordError::unhandled)?;
   76     67   
                let output = output.meta(generic);
   77     68   
                output.build()
   78     69   
            };
   79         -
            if tmp.message.is_none() {
   80         -
                tmp.message = _error_message;
   81         -
            }
   82     70   
            tmp
   83     71   
        }),
   84     72   
        "PasswordPolicyViolation" => crate::operation::change_password::ChangePasswordError::PasswordPolicyViolationException({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::PasswordPolicyViolationExceptionBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_password_policy_violation_exception::de_password_policy_violation_exception_xml_err(
   90     78   
                    _response_body,
   91     79   
                    output,
   92     80   
                )
   93     81   
                .map_err(crate::operation::change_password::ChangePasswordError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        "ServiceFailure" => crate::operation::change_password::ChangePasswordError::ServiceFailureException({
  103     88   
            #[allow(unused_mut)]
  104     89   
            let mut tmp = {
  105     90   
                #[allow(unused_mut)]
  106     91   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
  107     92   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
  108     93   
                    .map_err(crate::operation::change_password::ChangePasswordError::unhandled)?;
  109     94   
                let output = output.meta(generic);
  110     95   
                output.build()
  111     96   
            };
  112         -
            if tmp.message.is_none() {
  113         -
                tmp.message = _error_message;
  114         -
            }
  115     97   
            tmp
  116     98   
        }),
  117     99   
        _ => crate::operation::change_password::ChangePasswordError::generic(generic),
  118    100   
    })
  119    101   
}
  120    102   
  121    103   
#[allow(clippy::unnecessary_wraps)]
  122    104   
pub fn de_change_password_http_response(
  123    105   
    _response_status: u16,
  124    106   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +92,83 @@
   20     20   
        "LimitExceeded" => crate::operation::create_access_key::CreateAccessKeyError::LimitExceededException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::create_access_key::CreateAccessKeyError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "NoSuchEntity" => crate::operation::create_access_key::CreateAccessKeyError::NoSuchEntityException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::create_access_key::CreateAccessKeyError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "ServiceFailure" => crate::operation::create_access_key::CreateAccessKeyError::ServiceFailureException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::create_access_key::CreateAccessKeyError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        _ => crate::operation::create_access_key::CreateAccessKeyError::generic(generic),
   66     57   
    })
   67     58   
}
   68     59   
   69     60   
#[allow(clippy::unnecessary_wraps)]
   70     61   
pub fn de_create_access_key_http_response(
   71     62   
    _response_status: u16,
   72     63   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -6,6 +106,94 @@
   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::create_account_alias::CreateAccountAliasError::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   
        "EntityAlreadyExists" => crate::operation::create_account_alias::CreateAccountAliasError::EntityAlreadyExistsException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::EntityAlreadyExistsExceptionBuilder::default();
   46     43   
                output =
   47     44   
                    crate::protocol_serde::shape_entity_already_exists_exception::de_entity_already_exists_exception_xml_err(_response_body, output)
   48     45   
                        .map_err(crate::operation::create_account_alias::CreateAccountAliasError::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   
        "LimitExceeded" => crate::operation::create_account_alias::CreateAccountAliasError::LimitExceededException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::create_account_alias::CreateAccountAliasError::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::create_account_alias::CreateAccountAliasError::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::create_account_alias::CreateAccountAliasError::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::create_account_alias::CreateAccountAliasError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_create_account_alias_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_create_group.rs

@@ -1,1 +108,96 @@
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::EntityAlreadyExistsExceptionBuilder::default();
   25     25   
                output =
   26     26   
                    crate::protocol_serde::shape_entity_already_exists_exception::de_entity_already_exists_exception_xml_err(_response_body, output)
   27     27   
                        .map_err(crate::operation::create_group::CreateGroupError::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   
        "LimitExceeded" => crate::operation::create_group::CreateGroupError::LimitExceededException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::create_group::CreateGroupError::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   
        "NoSuchEntity" => crate::operation::create_group::CreateGroupError::NoSuchEntityException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::create_group::CreateGroupError::unhandled)?;
   58     52   
                let output = output.meta(generic);
   59     53   
                output.build()
   60     54   
            };
   61         -
            if tmp.message.is_none() {
   62         -
                tmp.message = _error_message;
   63         -
            }
   64     55   
            tmp
   65     56   
        }),
   66     57   
        "ServiceFailure" => crate::operation::create_group::CreateGroupError::ServiceFailureException({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::create_group::CreateGroupError::unhandled)?;
   73     64   
                let output = output.meta(generic);
   74     65   
                output.build()
   75     66   
            };
   76         -
            if tmp.message.is_none() {
   77         -
                tmp.message = _error_message;
   78         -
            }
   79     67   
            tmp
   80     68   
        }),
   81     69   
        _ => crate::operation::create_group::CreateGroupError::generic(generic),
   82     70   
    })
   83     71   
}
   84     72   
   85     73   
#[allow(clippy::unnecessary_wraps)]
   86     74   
pub fn de_create_group_http_response(
   87     75   
    _response_status: u16,
   88     76   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -6,6 +129,114 @@
   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::create_instance_profile::CreateInstanceProfileError::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   
        "EntityAlreadyExists" => crate::operation::create_instance_profile::CreateInstanceProfileError::EntityAlreadyExistsException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::EntityAlreadyExistsExceptionBuilder::default();
   46     43   
                output =
   47     44   
                    crate::protocol_serde::shape_entity_already_exists_exception::de_entity_already_exists_exception_xml_err(_response_body, output)
   48     45   
                        .map_err(crate::operation::create_instance_profile::CreateInstanceProfileError::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   
        "InvalidInput" => crate::operation::create_instance_profile::CreateInstanceProfileError::InvalidInputException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::create_instance_profile::CreateInstanceProfileError::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   
        "LimitExceeded" => crate::operation::create_instance_profile::CreateInstanceProfileError::LimitExceededException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::create_instance_profile::CreateInstanceProfileError::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   
        "ServiceFailure" => crate::operation::create_instance_profile::CreateInstanceProfileError::ServiceFailureException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::create_instance_profile::CreateInstanceProfileError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        _ => crate::operation::create_instance_profile::CreateInstanceProfileError::generic(generic),
  103     88   
    })
  104     89   
}
  105     90   
  106     91   
#[allow(clippy::unnecessary_wraps)]
  107     92   
pub fn de_create_instance_profile_http_response(
  108     93   
    _response_status: u16,
  109     94   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

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

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

@@ -7,7 +152,134 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::ConcurrentModificationExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_concurrent_modification_exception::de_concurrent_modification_exception_xml_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::create_open_id_connect_provider::CreateOpenIDConnectProviderError::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   
        "EntityAlreadyExists" => crate::operation::create_open_id_connect_provider::CreateOpenIDConnectProviderError::EntityAlreadyExistsException({
   44     41   
            #[allow(unused_mut)]
   45     42   
            let mut tmp = {
   46     43   
                #[allow(unused_mut)]
   47     44   
                let mut output = crate::types::error::builders::EntityAlreadyExistsExceptionBuilder::default();
   48     45   
                output =
   49     46   
                    crate::protocol_serde::shape_entity_already_exists_exception::de_entity_already_exists_exception_xml_err(_response_body, output)
   50     47   
                        .map_err(crate::operation::create_open_id_connect_provider::CreateOpenIDConnectProviderError::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   
        "InvalidInput" => crate::operation::create_open_id_connect_provider::CreateOpenIDConnectProviderError::InvalidInputException({
   60     54   
            #[allow(unused_mut)]
   61     55   
            let mut tmp = {
   62     56   
                #[allow(unused_mut)]
   63     57   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   64     58   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   65     59   
                    .map_err(crate::operation::create_open_id_connect_provider::CreateOpenIDConnectProviderError::unhandled)?;
   66     60   
                let output = output.meta(generic);
   67     61   
                output.build()
   68     62   
            };
   69         -
            if tmp.message.is_none() {
   70         -
                tmp.message = _error_message;
   71         -
            }
   72     63   
            tmp
   73     64   
        }),
   74     65   
        "LimitExceeded" => crate::operation::create_open_id_connect_provider::CreateOpenIDConnectProviderError::LimitExceededException({
   75     66   
            #[allow(unused_mut)]
   76     67   
            let mut tmp = {
   77     68   
                #[allow(unused_mut)]
   78     69   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   79     70   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   80     71   
                    .map_err(crate::operation::create_open_id_connect_provider::CreateOpenIDConnectProviderError::unhandled)?;
   81     72   
                let output = output.meta(generic);
   82     73   
                output.build()
   83     74   
            };
   84         -
            if tmp.message.is_none() {
   85         -
                tmp.message = _error_message;
   86         -
            }
   87     75   
            tmp
   88     76   
        }),
   89     77   
        "OpenIdIdpCommunicationError" => {
   90     78   
            crate::operation::create_open_id_connect_provider::CreateOpenIDConnectProviderError::OpenIdIdpCommunicationErrorException({
   91     79   
                #[allow(unused_mut)]
   92     80   
                let mut tmp = {
   93     81   
                    #[allow(unused_mut)]
   94     82   
                    let mut output = crate::types::error::builders::OpenIdIdpCommunicationErrorExceptionBuilder::default();
   95     83   
                    output =
   96     84   
                        crate::protocol_serde::shape_open_id_idp_communication_error_exception::de_open_id_idp_communication_error_exception_xml_err(
   97     85   
                            _response_body,
   98     86   
                            output,
   99     87   
                        )
  100     88   
                        .map_err(crate::operation::create_open_id_connect_provider::CreateOpenIDConnectProviderError::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   
        }
  110     95   
        "ServiceFailure" => crate::operation::create_open_id_connect_provider::CreateOpenIDConnectProviderError::ServiceFailureException({
  111     96   
            #[allow(unused_mut)]
  112     97   
            let mut tmp = {
  113     98   
                #[allow(unused_mut)]
  114     99   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
  115    100   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
  116    101   
                    .map_err(crate::operation::create_open_id_connect_provider::CreateOpenIDConnectProviderError::unhandled)?;
  117    102   
                let output = output.meta(generic);
  118    103   
                output.build()
  119    104   
            };
  120         -
            if tmp.message.is_none() {
  121         -
                tmp.message = _error_message;
  122         -
            }
  123    105   
            tmp
  124    106   
        }),
  125    107   
        _ => crate::operation::create_open_id_connect_provider::CreateOpenIDConnectProviderError::generic(generic),
  126    108   
    })
  127    109   
}
  128    110   
  129    111   
#[allow(clippy::unnecessary_wraps)]
  130    112   
pub fn de_create_open_id_connect_provider_http_response(
  131    113   
    _response_status: u16,
  132    114   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +144,126 @@
   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::create_policy::CreatePolicyError::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   
        "EntityAlreadyExists" => crate::operation::create_policy::CreatePolicyError::EntityAlreadyExistsException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::EntityAlreadyExistsExceptionBuilder::default();
   43     40   
                output =
   44     41   
                    crate::protocol_serde::shape_entity_already_exists_exception::de_entity_already_exists_exception_xml_err(_response_body, output)
   45     42   
                        .map_err(crate::operation::create_policy::CreatePolicyError::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   
        "InvalidInput" => crate::operation::create_policy::CreatePolicyError::InvalidInputException({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   60     54   
                    .map_err(crate::operation::create_policy::CreatePolicyError::unhandled)?;
   61     55   
                let output = output.meta(generic);
   62     56   
                output.build()
   63     57   
            };
   64         -
            if tmp.message.is_none() {
   65         -
                tmp.message = _error_message;
   66         -
            }
   67     58   
            tmp
   68     59   
        }),
   69     60   
        "LimitExceeded" => crate::operation::create_policy::CreatePolicyError::LimitExceededException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::create_policy::CreatePolicyError::unhandled)?;
   76     67   
                let output = output.meta(generic);
   77     68   
                output.build()
   78     69   
            };
   79         -
            if tmp.message.is_none() {
   80         -
                tmp.message = _error_message;
   81         -
            }
   82     70   
            tmp
   83     71   
        }),
   84     72   
        "MalformedPolicyDocument" => crate::operation::create_policy::CreatePolicyError::MalformedPolicyDocumentException({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::MalformedPolicyDocumentExceptionBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_malformed_policy_document_exception::de_malformed_policy_document_exception_xml_err(
   90     78   
                    _response_body,
   91     79   
                    output,
   92     80   
                )
   93     81   
                .map_err(crate::operation::create_policy::CreatePolicyError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        "ServiceFailure" => crate::operation::create_policy::CreatePolicyError::ServiceFailureException({
  103     88   
            #[allow(unused_mut)]
  104     89   
            let mut tmp = {
  105     90   
                #[allow(unused_mut)]
  106     91   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
  107     92   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
  108     93   
                    .map_err(crate::operation::create_policy::CreatePolicyError::unhandled)?;
  109     94   
                let output = output.meta(generic);
  110     95   
                output.build()
  111     96   
            };
  112         -
            if tmp.message.is_none() {
  113         -
                tmp.message = _error_message;
  114         -
            }
  115     97   
            tmp
  116     98   
        }),
  117     99   
        _ => crate::operation::create_policy::CreatePolicyError::generic(generic),
  118    100   
    })
  119    101   
}
  120    102   
  121    103   
#[allow(clippy::unnecessary_wraps)]
  122    104   
pub fn de_create_policy_http_response(
  123    105   
    _response_status: u16,
  124    106   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +128,113 @@
   23     23   
        "InvalidInput" => crate::operation::create_policy_version::CreatePolicyVersionError::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::create_policy_version::CreatePolicyVersionError::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   
        "LimitExceeded" => crate::operation::create_policy_version::CreatePolicyVersionError::LimitExceededException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::create_policy_version::CreatePolicyVersionError::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   
        "MalformedPolicyDocument" => crate::operation::create_policy_version::CreatePolicyVersionError::MalformedPolicyDocumentException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::MalformedPolicyDocumentExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_malformed_policy_document_exception::de_malformed_policy_document_exception_xml_err(
   59     53   
                    _response_body,
   60     54   
                    output,
   61     55   
                )
   62     56   
                .map_err(crate::operation::create_policy_version::CreatePolicyVersionError::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::create_policy_version::CreatePolicyVersionError::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::create_policy_version::CreatePolicyVersionError::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::create_policy_version::CreatePolicyVersionError::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::create_policy_version::CreatePolicyVersionError::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::create_policy_version::CreatePolicyVersionError::generic(generic),
  102     87   
    })
  103     88   
}
  104     89   
  105     90   
#[allow(clippy::unnecessary_wraps)]
  106     91   
pub fn de_create_policy_version_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_create_role.rs

@@ -3,3 +144,126 @@
   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::create_role::CreateRoleError::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   
        "EntityAlreadyExists" => crate::operation::create_role::CreateRoleError::EntityAlreadyExistsException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::EntityAlreadyExistsExceptionBuilder::default();
   43     40   
                output =
   44     41   
                    crate::protocol_serde::shape_entity_already_exists_exception::de_entity_already_exists_exception_xml_err(_response_body, output)
   45     42   
                        .map_err(crate::operation::create_role::CreateRoleError::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   
        "InvalidInput" => crate::operation::create_role::CreateRoleError::InvalidInputException({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   60     54   
                    .map_err(crate::operation::create_role::CreateRoleError::unhandled)?;
   61     55   
                let output = output.meta(generic);
   62     56   
                output.build()
   63     57   
            };
   64         -
            if tmp.message.is_none() {
   65         -
                tmp.message = _error_message;
   66         -
            }
   67     58   
            tmp
   68     59   
        }),
   69     60   
        "LimitExceeded" => crate::operation::create_role::CreateRoleError::LimitExceededException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::create_role::CreateRoleError::unhandled)?;
   76     67   
                let output = output.meta(generic);
   77     68   
                output.build()
   78     69   
            };
   79         -
            if tmp.message.is_none() {
   80         -
                tmp.message = _error_message;
   81         -
            }
   82     70   
            tmp
   83     71   
        }),
   84     72   
        "MalformedPolicyDocument" => crate::operation::create_role::CreateRoleError::MalformedPolicyDocumentException({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::MalformedPolicyDocumentExceptionBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_malformed_policy_document_exception::de_malformed_policy_document_exception_xml_err(
   90     78   
                    _response_body,
   91     79   
                    output,
   92     80   
                )
   93     81   
                .map_err(crate::operation::create_role::CreateRoleError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        "ServiceFailure" => crate::operation::create_role::CreateRoleError::ServiceFailureException({
  103     88   
            #[allow(unused_mut)]
  104     89   
            let mut tmp = {
  105     90   
                #[allow(unused_mut)]
  106     91   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
  107     92   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
  108     93   
                    .map_err(crate::operation::create_role::CreateRoleError::unhandled)?;
  109     94   
                let output = output.meta(generic);
  110     95   
                output.build()
  111     96   
            };
  112         -
            if tmp.message.is_none() {
  113         -
                tmp.message = _error_message;
  114         -
            }
  115     97   
            tmp
  116     98   
        }),
  117     99   
        _ => crate::operation::create_role::CreateRoleError::generic(generic),
  118    100   
    })
  119    101   
}
  120    102   
  121    103   
#[allow(clippy::unnecessary_wraps)]
  122    104   
pub fn de_create_role_http_response(
  123    105   
    _response_status: u16,
  124    106   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -6,6 +129,114 @@
   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::create_saml_provider::CreateSAMLProviderError::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   
        "EntityAlreadyExists" => crate::operation::create_saml_provider::CreateSAMLProviderError::EntityAlreadyExistsException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::EntityAlreadyExistsExceptionBuilder::default();
   46     43   
                output =
   47     44   
                    crate::protocol_serde::shape_entity_already_exists_exception::de_entity_already_exists_exception_xml_err(_response_body, output)
   48     45   
                        .map_err(crate::operation::create_saml_provider::CreateSAMLProviderError::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   
        "InvalidInput" => crate::operation::create_saml_provider::CreateSAMLProviderError::InvalidInputException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::create_saml_provider::CreateSAMLProviderError::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   
        "LimitExceeded" => crate::operation::create_saml_provider::CreateSAMLProviderError::LimitExceededException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::create_saml_provider::CreateSAMLProviderError::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   
        "ServiceFailure" => crate::operation::create_saml_provider::CreateSAMLProviderError::ServiceFailureException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::create_saml_provider::CreateSAMLProviderError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        _ => crate::operation::create_saml_provider::CreateSAMLProviderError::generic(generic),
  103     88   
    })
  104     89   
}
  105     90   
  106     91   
#[allow(clippy::unnecessary_wraps)]
  107     92   
pub fn de_create_saml_provider_http_response(
  108     93   
    _response_status: u16,
  109     94   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +114,102 @@
   27     27   
        "InvalidInput" => crate::operation::create_service_linked_role::CreateServiceLinkedRoleError::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::create_service_linked_role::CreateServiceLinkedRoleError::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::create_service_linked_role::CreateServiceLinkedRoleError::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::create_service_linked_role::CreateServiceLinkedRoleError::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::create_service_linked_role::CreateServiceLinkedRoleError::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::create_service_linked_role::CreateServiceLinkedRoleError::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::create_service_linked_role::CreateServiceLinkedRoleError::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::create_service_linked_role::CreateServiceLinkedRoleError::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::create_service_linked_role::CreateServiceLinkedRoleError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_create_service_linked_role_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_create_service_specific_credential.rs

@@ -3,3 +99,90 @@
   23     23   
        "LimitExceeded" => crate::operation::create_service_specific_credential::CreateServiceSpecificCredentialError::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::create_service_specific_credential::CreateServiceSpecificCredentialError::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::create_service_specific_credential::CreateServiceSpecificCredentialError::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::create_service_specific_credential::CreateServiceSpecificCredentialError::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   
        "NotSupportedService" => {
   54     48   
            crate::operation::create_service_specific_credential::CreateServiceSpecificCredentialError::ServiceNotSupportedException({
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut tmp = {
   57     51   
                    #[allow(unused_mut)]
   58     52   
                    let mut output = crate::types::error::builders::ServiceNotSupportedExceptionBuilder::default();
   59     53   
                    output = crate::protocol_serde::shape_service_not_supported_exception::de_service_not_supported_exception_xml_err(
   60     54   
                        _response_body,
   61     55   
                        output,
   62     56   
                    )
   63     57   
                    .map_err(crate::operation::create_service_specific_credential::CreateServiceSpecificCredentialError::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   
        }
   73     64   
        _ => crate::operation::create_service_specific_credential::CreateServiceSpecificCredentialError::generic(generic),
   74     65   
    })
   75     66   
}
   76     67   
   77     68   
#[allow(clippy::unnecessary_wraps)]
   78     69   
pub fn de_create_service_specific_credential_http_response(
   79     70   
    _response_status: u16,

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

@@ -3,3 +141,123 @@
   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::create_user::CreateUserError::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   
        "EntityAlreadyExists" => crate::operation::create_user::CreateUserError::EntityAlreadyExistsException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::EntityAlreadyExistsExceptionBuilder::default();
   43     40   
                output =
   44     41   
                    crate::protocol_serde::shape_entity_already_exists_exception::de_entity_already_exists_exception_xml_err(_response_body, output)
   45     42   
                        .map_err(crate::operation::create_user::CreateUserError::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   
        "InvalidInput" => crate::operation::create_user::CreateUserError::InvalidInputException({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   60     54   
                    .map_err(crate::operation::create_user::CreateUserError::unhandled)?;
   61     55   
                let output = output.meta(generic);
   62     56   
                output.build()
   63     57   
            };
   64         -
            if tmp.message.is_none() {
   65         -
                tmp.message = _error_message;
   66         -
            }
   67     58   
            tmp
   68     59   
        }),
   69     60   
        "LimitExceeded" => crate::operation::create_user::CreateUserError::LimitExceededException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::create_user::CreateUserError::unhandled)?;
   76     67   
                let output = output.meta(generic);
   77     68   
                output.build()
   78     69   
            };
   79         -
            if tmp.message.is_none() {
   80         -
                tmp.message = _error_message;
   81         -
            }
   82     70   
            tmp
   83     71   
        }),
   84     72   
        "NoSuchEntity" => crate::operation::create_user::CreateUserError::NoSuchEntityException({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   90     78   
                    .map_err(crate::operation::create_user::CreateUserError::unhandled)?;
   91     79   
                let output = output.meta(generic);
   92     80   
                output.build()
   93     81   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     82   
            tmp
   98     83   
        }),
   99     84   
        "ServiceFailure" => crate::operation::create_user::CreateUserError::ServiceFailureException({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
  105     90   
                    .map_err(crate::operation::create_user::CreateUserError::unhandled)?;
  106     91   
                let output = output.meta(generic);
  107     92   
                output.build()
  108     93   
            };
  109         -
            if tmp.message.is_none() {
  110         -
                tmp.message = _error_message;
  111         -
            }
  112     94   
            tmp
  113     95   
        }),
  114     96   
        _ => crate::operation::create_user::CreateUserError::generic(generic),
  115     97   
    })
  116     98   
}
  117     99   
  118    100   
#[allow(clippy::unnecessary_wraps)]
  119    101   
pub fn de_create_user_http_response(
  120    102   
    _response_status: u16,
  121    103   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,