AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df

Files changed:

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

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

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

@@ -6,6 +126,111 @@
   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::deactivate_mfa_device::DeactivateMFADeviceError::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   
        "EntityTemporarilyUnmodifiable" => {
   42     39   
            crate::operation::deactivate_mfa_device::DeactivateMFADeviceError::EntityTemporarilyUnmodifiableException({
   43     40   
                #[allow(unused_mut)]
   44     41   
                let mut tmp = {
   45     42   
                    #[allow(unused_mut)]
   46     43   
                    let mut output = crate::types::error::builders::EntityTemporarilyUnmodifiableExceptionBuilder::default();
   47     44   
                    output =
   48     45   
                        crate::protocol_serde::shape_entity_temporarily_unmodifiable_exception::de_entity_temporarily_unmodifiable_exception_xml_err(
   49     46   
                            _response_body,
   50     47   
                            output,
   51     48   
                        )
   52     49   
                        .map_err(crate::operation::deactivate_mfa_device::DeactivateMFADeviceError::unhandled)?;
   53     50   
                    let output = output.meta(generic);
   54     51   
                    output.build()
   55     52   
                };
   56         -
                if tmp.message.is_none() {
   57         -
                    tmp.message = _error_message;
   58         -
                }
   59     53   
                tmp
   60     54   
            })
   61     55   
        }
   62     56   
        "LimitExceeded" => crate::operation::deactivate_mfa_device::DeactivateMFADeviceError::LimitExceededException({
   63     57   
            #[allow(unused_mut)]
   64     58   
            let mut tmp = {
   65     59   
                #[allow(unused_mut)]
   66     60   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   67     61   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   68     62   
                    .map_err(crate::operation::deactivate_mfa_device::DeactivateMFADeviceError::unhandled)?;
   69     63   
                let output = output.meta(generic);
   70     64   
                output.build()
   71     65   
            };
   72         -
            if tmp.message.is_none() {
   73         -
                tmp.message = _error_message;
   74         -
            }
   75     66   
            tmp
   76     67   
        }),
   77     68   
        "NoSuchEntity" => crate::operation::deactivate_mfa_device::DeactivateMFADeviceError::NoSuchEntityException({
   78     69   
            #[allow(unused_mut)]
   79     70   
            let mut tmp = {
   80     71   
                #[allow(unused_mut)]
   81     72   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   82     73   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   83     74   
                    .map_err(crate::operation::deactivate_mfa_device::DeactivateMFADeviceError::unhandled)?;
   84     75   
                let output = output.meta(generic);
   85     76   
                output.build()
   86     77   
            };
   87         -
            if tmp.message.is_none() {
   88         -
                tmp.message = _error_message;
   89         -
            }
   90     78   
            tmp
   91     79   
        }),
   92     80   
        "ServiceFailure" => crate::operation::deactivate_mfa_device::DeactivateMFADeviceError::ServiceFailureException({
   93     81   
            #[allow(unused_mut)]
   94     82   
            let mut tmp = {
   95     83   
                #[allow(unused_mut)]
   96     84   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   97     85   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   98     86   
                    .map_err(crate::operation::deactivate_mfa_device::DeactivateMFADeviceError::unhandled)?;
   99     87   
                let output = output.meta(generic);
  100     88   
                output.build()
  101     89   
            };
  102         -
            if tmp.message.is_none() {
  103         -
                tmp.message = _error_message;
  104         -
            }
  105     90   
            tmp
  106     91   
        }),
  107     92   
        _ => crate::operation::deactivate_mfa_device::DeactivateMFADeviceError::generic(generic),
  108     93   
    })
  109     94   
}
  110     95   
  111     96   
#[allow(clippy::unnecessary_wraps)]
  112     97   
pub fn de_deactivate_mfa_device_http_response(
  113     98   
    _response_status: u16,
  114     99   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +81,72 @@
   20     20   
        "LimitExceeded" => crate::operation::delete_access_key::DeleteAccessKeyError::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::delete_access_key::DeleteAccessKeyError::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::delete_access_key::DeleteAccessKeyError::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::delete_access_key::DeleteAccessKeyError::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::delete_access_key::DeleteAccessKeyError::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::delete_access_key::DeleteAccessKeyError::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::delete_access_key::DeleteAccessKeyError::generic(generic),
   66     57   
    })
   67     58   
}
   68     59   
   69     60   
#[allow(clippy::unnecessary_wraps)]
   70     61   
pub fn de_delete_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_delete_account_alias.rs

@@ -6,6 +105,93 @@
   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::delete_account_alias::DeleteAccountAliasError::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   
        "LimitExceeded" => crate::operation::delete_account_alias::DeleteAccountAliasError::LimitExceededException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::delete_account_alias::DeleteAccountAliasError::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   
        "NoSuchEntity" => crate::operation::delete_account_alias::DeleteAccountAliasError::NoSuchEntityException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::delete_account_alias::DeleteAccountAliasError::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   
        "ServiceFailure" => crate::operation::delete_account_alias::DeleteAccountAliasError::ServiceFailureException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::delete_account_alias::DeleteAccountAliasError::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   
        _ => crate::operation::delete_account_alias::DeleteAccountAliasError::generic(generic),
   87     75   
    })
   88     76   
}
   89     77   
   90     78   
#[allow(clippy::unnecessary_wraps)]
   91     79   
pub fn de_delete_account_alias_http_response(
   92     80   
    _response_status: u16,
   93     81   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +87,78 @@
   23     23   
        "LimitExceeded" => crate::operation::delete_account_password_policy::DeleteAccountPasswordPolicyError::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::delete_account_password_policy::DeleteAccountPasswordPolicyError::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::delete_account_password_policy::DeleteAccountPasswordPolicyError::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::delete_account_password_policy::DeleteAccountPasswordPolicyError::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::delete_account_password_policy::DeleteAccountPasswordPolicyError::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::delete_account_password_policy::DeleteAccountPasswordPolicyError::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::delete_account_password_policy::DeleteAccountPasswordPolicyError::generic(generic),
   69     60   
    })
   70     61   
}
   71     62   
   72     63   
#[allow(clippy::unnecessary_wraps)]
   73     64   
pub fn de_delete_account_password_policy_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_delete_group.rs

@@ -1,1 +96,84 @@
   20     20   
        "DeleteConflict" => crate::operation::delete_group::DeleteGroupError::DeleteConflictException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::DeleteConflictExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_delete_conflict_exception::de_delete_conflict_exception_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::delete_group::DeleteGroupError::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::delete_group::DeleteGroupError::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::delete_group::DeleteGroupError::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::delete_group::DeleteGroupError::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::delete_group::DeleteGroupError::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   
        "ServiceFailure" => crate::operation::delete_group::DeleteGroupError::ServiceFailureException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::delete_group::DeleteGroupError::unhandled)?;
   72     63   
                let output = output.meta(generic);
   73     64   
                output.build()
   74     65   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     66   
            tmp
   79     67   
        }),
   80     68   
        _ => crate::operation::delete_group::DeleteGroupError::generic(generic),
   81     69   
    })
   82     70   
}
   83     71   
   84     72   
#[allow(clippy::unnecessary_wraps)]
   85     73   
pub fn de_delete_group_http_response(
   86     74   
    _response_status: u16,
   87     75   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +83,74 @@
   21     21   
        "LimitExceeded" => crate::operation::delete_group_policy::DeleteGroupPolicyError::LimitExceededException({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::delete_group_policy::DeleteGroupPolicyError::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   
        "NoSuchEntity" => crate::operation::delete_group_policy::DeleteGroupPolicyError::NoSuchEntityException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::delete_group_policy::DeleteGroupPolicyError::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   
        "ServiceFailure" => crate::operation::delete_group_policy::DeleteGroupPolicyError::ServiceFailureException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::delete_group_policy::DeleteGroupPolicyError::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   
        _ => crate::operation::delete_group_policy::DeleteGroupPolicyError::generic(generic),
   67     58   
    })
   68     59   
}
   69     60   
   70     61   
#[allow(clippy::unnecessary_wraps)]
   71     62   
pub fn de_delete_group_policy_http_response(
   72     63   
    _response_status: u16,
   73     64   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +102,90 @@
   23     23   
        "DeleteConflict" => crate::operation::delete_instance_profile::DeleteInstanceProfileError::DeleteConflictException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::DeleteConflictExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_delete_conflict_exception::de_delete_conflict_exception_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::delete_instance_profile::DeleteInstanceProfileError::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::delete_instance_profile::DeleteInstanceProfileError::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::delete_instance_profile::DeleteInstanceProfileError::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   
        "NoSuchEntity" => crate::operation::delete_instance_profile::DeleteInstanceProfileError::NoSuchEntityException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::delete_instance_profile::DeleteInstanceProfileError::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   
        "ServiceFailure" => crate::operation::delete_instance_profile::DeleteInstanceProfileError::ServiceFailureException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::delete_instance_profile::DeleteInstanceProfileError::unhandled)?;
   75     66   
                let output = output.meta(generic);
   76     67   
                output.build()
   77     68   
            };
   78         -
            if tmp.message.is_none() {
   79         -
                tmp.message = _error_message;
   80         -
            }
   81     69   
            tmp
   82     70   
        }),
   83     71   
        _ => crate::operation::delete_instance_profile::DeleteInstanceProfileError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_delete_instance_profile_http_response(
   89     77   
    _response_status: u16,
   90     78   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +106,94 @@
   27     27   
                let mut output = crate::types::error::builders::EntityTemporarilyUnmodifiableExceptionBuilder::default();
   28     28   
                output =
   29     29   
                    crate::protocol_serde::shape_entity_temporarily_unmodifiable_exception::de_entity_temporarily_unmodifiable_exception_xml_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::delete_login_profile::DeleteLoginProfileError::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::delete_login_profile::DeleteLoginProfileError::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::delete_login_profile::DeleteLoginProfileError::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::delete_login_profile::DeleteLoginProfileError::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::delete_login_profile::DeleteLoginProfileError::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::delete_login_profile::DeleteLoginProfileError::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::delete_login_profile::DeleteLoginProfileError::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::delete_login_profile::DeleteLoginProfileError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_delete_login_profile_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_delete_open_id_connect_provider.rs

@@ -3,3 +87,78 @@
   23     23   
        "InvalidInput" => crate::operation::delete_open_id_connect_provider::DeleteOpenIDConnectProviderError::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::delete_open_id_connect_provider::DeleteOpenIDConnectProviderError::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::delete_open_id_connect_provider::DeleteOpenIDConnectProviderError::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::delete_open_id_connect_provider::DeleteOpenIDConnectProviderError::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::delete_open_id_connect_provider::DeleteOpenIDConnectProviderError::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::delete_open_id_connect_provider::DeleteOpenIDConnectProviderError::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::delete_open_id_connect_provider::DeleteOpenIDConnectProviderError::generic(generic),
   69     60   
    })
   70     61   
}
   71     62   
   72     63   
#[allow(clippy::unnecessary_wraps)]
   73     64   
pub fn de_delete_open_id_connect_provider_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_delete_policy.rs

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

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

@@ -3,3 +117,102 @@
   23     23   
        "DeleteConflict" => crate::operation::delete_policy_version::DeletePolicyVersionError::DeleteConflictException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::DeleteConflictExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_delete_conflict_exception::de_delete_conflict_exception_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::delete_policy_version::DeletePolicyVersionError::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::delete_policy_version::DeletePolicyVersionError::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::delete_policy_version::DeletePolicyVersionError::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::delete_policy_version::DeletePolicyVersionError::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::delete_policy_version::DeletePolicyVersionError::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::delete_policy_version::DeletePolicyVersionError::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::delete_policy_version::DeletePolicyVersionError::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::delete_policy_version::DeletePolicyVersionError::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::delete_policy_version::DeletePolicyVersionError::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::delete_policy_version::DeletePolicyVersionError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_delete_policy_version_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_delete_role.rs

@@ -3,3 +129,111 @@
   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::delete_role::DeleteRoleError::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   
        "DeleteConflict" => crate::operation::delete_role::DeleteRoleError::DeleteConflictException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::DeleteConflictExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_delete_conflict_exception::de_delete_conflict_exception_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::delete_role::DeleteRoleError::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::delete_role::DeleteRoleError::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::delete_role::DeleteRoleError::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::delete_role::DeleteRoleError::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::delete_role::DeleteRoleError::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::delete_role::DeleteRoleError::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::delete_role::DeleteRoleError::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   
        "UnmodifiableEntity" => crate::operation::delete_role::DeleteRoleError::UnmodifiableEntityException({
   99     84   
            #[allow(unused_mut)]
  100     85   
            let mut tmp = {
  101     86   
                #[allow(unused_mut)]
  102     87   
                let mut output = crate::types::error::builders::UnmodifiableEntityExceptionBuilder::default();
  103     88   
                output = crate::protocol_serde::shape_unmodifiable_entity_exception::de_unmodifiable_entity_exception_xml_err(_response_body, output)
  104     89   
                    .map_err(crate::operation::delete_role::DeleteRoleError::unhandled)?;
  105     90   
                let output = output.meta(generic);
  106     91   
                output.build()
  107     92   
            };
  108         -
            if tmp.message.is_none() {
  109         -
                tmp.message = _error_message;
  110         -
            }
  111     93   
            tmp
  112     94   
        }),
  113     95   
        _ => crate::operation::delete_role::DeleteRoleError::generic(generic),
  114     96   
    })
  115     97   
}
  116     98   
  117     99   
#[allow(clippy::unnecessary_wraps)]
  118    100   
pub fn de_delete_role_http_response(
  119    101   
    _response_status: u16,
  120    102   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +90,81 @@
   23     23   
        "NoSuchEntity" => crate::operation::delete_role_permissions_boundary::DeleteRolePermissionsBoundaryError::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::delete_role_permissions_boundary::DeleteRolePermissionsBoundaryError::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   
        "ServiceFailure" => crate::operation::delete_role_permissions_boundary::DeleteRolePermissionsBoundaryError::ServiceFailureException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::delete_role_permissions_boundary::DeleteRolePermissionsBoundaryError::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   
        "UnmodifiableEntity" => {
   54     48   
            crate::operation::delete_role_permissions_boundary::DeleteRolePermissionsBoundaryError::UnmodifiableEntityException({
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut tmp = {
   57     51   
                    #[allow(unused_mut)]
   58     52   
                    let mut output = crate::types::error::builders::UnmodifiableEntityExceptionBuilder::default();
   59     53   
                    output =
   60     54   
                        crate::protocol_serde::shape_unmodifiable_entity_exception::de_unmodifiable_entity_exception_xml_err(_response_body, output)
   61     55   
                            .map_err(crate::operation::delete_role_permissions_boundary::DeleteRolePermissionsBoundaryError::unhandled)?;
   62     56   
                    let output = output.meta(generic);
   63     57   
                    output.build()
   64     58   
                };
   65         -
                if tmp.message.is_none() {
   66         -
                    tmp.message = _error_message;
   67         -
                }
   68     59   
                tmp
   69     60   
            })
   70     61   
        }
   71     62   
        _ => crate::operation::delete_role_permissions_boundary::DeleteRolePermissionsBoundaryError::generic(generic),
   72     63   
    })
   73     64   
}
   74     65   
   75     66   
#[allow(clippy::unnecessary_wraps)]
   76     67   
pub fn de_delete_role_permissions_boundary_http_response(
   77     68   
    _response_status: u16,

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

@@ -1,1 +96,84 @@
   20     20   
        "LimitExceeded" => crate::operation::delete_role_policy::DeleteRolePolicyError::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::delete_role_policy::DeleteRolePolicyError::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::delete_role_policy::DeleteRolePolicyError::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::delete_role_policy::DeleteRolePolicyError::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::delete_role_policy::DeleteRolePolicyError::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::delete_role_policy::DeleteRolePolicyError::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   
        "UnmodifiableEntity" => crate::operation::delete_role_policy::DeleteRolePolicyError::UnmodifiableEntityException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::UnmodifiableEntityExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_unmodifiable_entity_exception::de_unmodifiable_entity_exception_xml_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::delete_role_policy::DeleteRolePolicyError::unhandled)?;
   72     63   
                let output = output.meta(generic);
   73     64   
                output.build()
   74     65   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     66   
            tmp
   79     67   
        }),
   80     68   
        _ => crate::operation::delete_role_policy::DeleteRolePolicyError::generic(generic),
   81     69   
    })
   82     70   
}
   83     71   
   84     72   
#[allow(clippy::unnecessary_wraps)]
   85     73   
pub fn de_delete_role_policy_http_response(
   86     74   
    _response_status: u16,
   87     75   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +102,90 @@
   23     23   
        "InvalidInput" => crate::operation::delete_saml_provider::DeleteSAMLProviderError::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::delete_saml_provider::DeleteSAMLProviderError::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::delete_saml_provider::DeleteSAMLProviderError::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::delete_saml_provider::DeleteSAMLProviderError::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   
        "NoSuchEntity" => crate::operation::delete_saml_provider::DeleteSAMLProviderError::NoSuchEntityException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::delete_saml_provider::DeleteSAMLProviderError::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   
        "ServiceFailure" => crate::operation::delete_saml_provider::DeleteSAMLProviderError::ServiceFailureException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::delete_saml_provider::DeleteSAMLProviderError::unhandled)?;
   75     66   
                let output = output.meta(generic);
   76     67   
                output.build()
   77     68   
            };
   78         -
            if tmp.message.is_none() {
   79         -
                tmp.message = _error_message;
   80         -
            }
   81     69   
            tmp
   82     70   
        }),
   83     71   
        _ => crate::operation::delete_saml_provider::DeleteSAMLProviderError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_delete_saml_provider_http_response(
   89     77   
    _response_status: u16,
   90     78   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,