AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05

Files changed:

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

@@ -3,3 +95,86 @@
   23     23   
        "InvalidInput" => crate::operation::list_saml_provider_tags::ListSAMLProviderTagsError::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::list_saml_provider_tags::ListSAMLProviderTagsError::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::list_saml_provider_tags::ListSAMLProviderTagsError::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::list_saml_provider_tags::ListSAMLProviderTagsError::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::list_saml_provider_tags::ListSAMLProviderTagsError::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::list_saml_provider_tags::ListSAMLProviderTagsError::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::list_saml_provider_tags::ListSAMLProviderTagsError::generic(generic),
   69     60   
    })
   70     61   
}
   71     62   
   72     63   
#[allow(clippy::unnecessary_wraps)]
   73     64   
pub fn de_list_saml_provider_tags_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_list_saml_providers.rs

@@ -1,1 +63,60 @@
   21     21   
        "ServiceFailure" => crate::operation::list_saml_providers::ListSAMLProvidersError::ServiceFailureException({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::list_saml_providers::ListSAMLProvidersError::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   
        _ => crate::operation::list_saml_providers::ListSAMLProvidersError::generic(generic),
   37     34   
    })
   38     35   
}
   39     36   
   40     37   
#[allow(clippy::unnecessary_wraps)]
   41     38   
pub fn de_list_saml_providers_http_response(
   42     39   
    _response_status: u16,
   43     40   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +84,78 @@
   27     27   
        "NoSuchEntity" => crate::operation::list_server_certificate_tags::ListServerCertificateTagsError::NoSuchEntityException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::list_server_certificate_tags::ListServerCertificateTagsError::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   
        "ServiceFailure" => crate::operation::list_server_certificate_tags::ListServerCertificateTagsError::ServiceFailureException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::list_server_certificate_tags::ListServerCertificateTagsError::unhandled)?;
   49     46   
                let output = output.meta(generic);
   50     47   
                output.build()
   51     48   
            };
   52         -
            if tmp.message.is_none() {
   53         -
                tmp.message = _error_message;
   54         -
            }
   55     49   
            tmp
   56     50   
        }),
   57     51   
        _ => crate::operation::list_server_certificate_tags::ListServerCertificateTagsError::generic(generic),
   58     52   
    })
   59     53   
}
   60     54   
   61     55   
#[allow(clippy::unnecessary_wraps)]
   62     56   
pub fn de_list_server_certificate_tags_http_response(
   63     57   
    _response_status: u16,
   64     58   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +69,66 @@
   27     27   
        "ServiceFailure" => crate::operation::list_server_certificates::ListServerCertificatesError::ServiceFailureException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::list_server_certificates::ListServerCertificatesError::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   
        _ => crate::operation::list_server_certificates::ListServerCertificatesError::generic(generic),
   43     40   
    })
   44     41   
}
   45     42   
   46     43   
#[allow(clippy::unnecessary_wraps)]
   47     44   
pub fn de_list_server_certificates_http_response(
   48     45   
    _response_status: u16,
   49     46   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +84,78 @@
   23     23   
        "NoSuchEntity" => crate::operation::list_service_specific_credentials::ListServiceSpecificCredentialsError::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::list_service_specific_credentials::ListServiceSpecificCredentialsError::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   
        "NotSupportedService" => {
   39     36   
            crate::operation::list_service_specific_credentials::ListServiceSpecificCredentialsError::ServiceNotSupportedException({
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut tmp = {
   42     39   
                    #[allow(unused_mut)]
   43     40   
                    let mut output = crate::types::error::builders::ServiceNotSupportedExceptionBuilder::default();
   44     41   
                    output = crate::protocol_serde::shape_service_not_supported_exception::de_service_not_supported_exception_xml_err(
   45     42   
                        _response_body,
   46     43   
                        output,
   47     44   
                    )
   48     45   
                    .map_err(crate::operation::list_service_specific_credentials::ListServiceSpecificCredentialsError::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   
        }
   58     52   
        _ => crate::operation::list_service_specific_credentials::ListServiceSpecificCredentialsError::generic(generic),
   59     53   
    })
   60     54   
}
   61     55   
   62     56   
#[allow(clippy::unnecessary_wraps)]
   63     57   
pub fn de_list_service_specific_credentials_http_response(
   64     58   
    _response_status: u16,

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

@@ -7,7 +84,78 @@
   27     27   
        "NoSuchEntity" => crate::operation::list_signing_certificates::ListSigningCertificatesError::NoSuchEntityException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::list_signing_certificates::ListSigningCertificatesError::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   
        "ServiceFailure" => crate::operation::list_signing_certificates::ListSigningCertificatesError::ServiceFailureException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::list_signing_certificates::ListSigningCertificatesError::unhandled)?;
   49     46   
                let output = output.meta(generic);
   50     47   
                output.build()
   51     48   
            };
   52         -
            if tmp.message.is_none() {
   53         -
                tmp.message = _error_message;
   54         -
            }
   55     49   
            tmp
   56     50   
        }),
   57     51   
        _ => crate::operation::list_signing_certificates::ListSigningCertificatesError::generic(generic),
   58     52   
    })
   59     53   
}
   60     54   
   61     55   
#[allow(clippy::unnecessary_wraps)]
   62     56   
pub fn de_list_signing_certificates_http_response(
   63     57   
    _response_status: u16,
   64     58   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +65,62 @@
   23     23   
        "NoSuchEntity" => crate::operation::list_ssh_public_keys::ListSSHPublicKeysError::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::list_ssh_public_keys::ListSSHPublicKeysError::unhandled)?;
   30     30   
                let output = output.meta(generic);
   31     31   
                output.build()
   32     32   
            };
   33         -
            if tmp.message.is_none() {
   34         -
                tmp.message = _error_message;
   35         -
            }
   36     33   
            tmp
   37     34   
        }),
   38     35   
        _ => crate::operation::list_ssh_public_keys::ListSSHPublicKeysError::generic(generic),
   39     36   
    })
   40     37   
}
   41     38   
   42     39   
#[allow(clippy::unnecessary_wraps)]
   43     40   
pub fn de_list_ssh_public_keys_http_response(
   44     41   
    _response_status: u16,
   45     42   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +77,71 @@
   20     20   
        "NoSuchEntity" => crate::operation::list_user_policies::ListUserPoliciesError::NoSuchEntityException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::list_user_policies::ListUserPoliciesError::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   
        "ServiceFailure" => crate::operation::list_user_policies::ListUserPoliciesError::ServiceFailureException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::list_user_policies::ListUserPoliciesError::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   
        _ => crate::operation::list_user_policies::ListUserPoliciesError::generic(generic),
   51     45   
    })
   52     46   
}
   53     47   
   54     48   
#[allow(clippy::unnecessary_wraps)]
   55     49   
pub fn de_list_user_policies_http_response(
   56     50   
    _response_status: u16,
   57     51   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +77,71 @@
   20     20   
        "NoSuchEntity" => crate::operation::list_user_tags::ListUserTagsError::NoSuchEntityException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::list_user_tags::ListUserTagsError::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   
        "ServiceFailure" => crate::operation::list_user_tags::ListUserTagsError::ServiceFailureException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::list_user_tags::ListUserTagsError::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   
        _ => crate::operation::list_user_tags::ListUserTagsError::generic(generic),
   51     45   
    })
   52     46   
}
   53     47   
   54     48   
#[allow(clippy::unnecessary_wraps)]
   55     49   
pub fn de_list_user_tags_http_response(
   56     50   
    _response_status: u16,
   57     51   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +62,59 @@
   20     20   
        "ServiceFailure" => crate::operation::list_users::ListUsersError::ServiceFailureException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::list_users::ListUsersError::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   
        _ => crate::operation::list_users::ListUsersError::generic(generic),
   36     33   
    })
   37     34   
}
   38     35   
   39     36   
#[allow(clippy::unnecessary_wraps)]
   40     37   
pub fn de_list_users_http_response(
   41     38   
    _response_status: u16,
   42     39   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +99,87 @@
   20     20   
        "LimitExceeded" => crate::operation::put_group_policy::PutGroupPolicyError::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::put_group_policy::PutGroupPolicyError::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   
        "MalformedPolicyDocument" => crate::operation::put_group_policy::PutGroupPolicyError::MalformedPolicyDocumentException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::MalformedPolicyDocumentExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_malformed_policy_document_exception::de_malformed_policy_document_exception_xml_err(
   41     38   
                    _response_body,
   42     39   
                    output,
   43     40   
                )
   44     41   
                .map_err(crate::operation::put_group_policy::PutGroupPolicyError::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::put_group_policy::PutGroupPolicyError::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::put_group_policy::PutGroupPolicyError::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::put_group_policy::PutGroupPolicyError::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::put_group_policy::PutGroupPolicyError::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::put_group_policy::PutGroupPolicyError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_put_group_policy_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_put_role_permissions_boundary.rs

@@ -3,3 +118,103 @@
   23     23   
        "InvalidInput" => crate::operation::put_role_permissions_boundary::PutRolePermissionsBoundaryError::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::put_role_permissions_boundary::PutRolePermissionsBoundaryError::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::put_role_permissions_boundary::PutRolePermissionsBoundaryError::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::put_role_permissions_boundary::PutRolePermissionsBoundaryError::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   
        "PolicyNotAttachable" => crate::operation::put_role_permissions_boundary::PutRolePermissionsBoundaryError::PolicyNotAttachableException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::PolicyNotAttachableExceptionBuilder::default();
   58     52   
                output =
   59     53   
                    crate::protocol_serde::shape_policy_not_attachable_exception::de_policy_not_attachable_exception_xml_err(_response_body, output)
   60     54   
                        .map_err(crate::operation::put_role_permissions_boundary::PutRolePermissionsBoundaryError::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   
        "ServiceFailure" => crate::operation::put_role_permissions_boundary::PutRolePermissionsBoundaryError::ServiceFailureException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::put_role_permissions_boundary::PutRolePermissionsBoundaryError::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   
        "UnmodifiableEntity" => crate::operation::put_role_permissions_boundary::PutRolePermissionsBoundaryError::UnmodifiableEntityException({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::UnmodifiableEntityExceptionBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_unmodifiable_entity_exception::de_unmodifiable_entity_exception_xml_err(_response_body, output)
   90     78   
                    .map_err(crate::operation::put_role_permissions_boundary::PutRolePermissionsBoundaryError::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   
        _ => crate::operation::put_role_permissions_boundary::PutRolePermissionsBoundaryError::generic(generic),
  100     85   
    })
  101     86   
}
  102     87   
  103     88   
#[allow(clippy::unnecessary_wraps)]
  104     89   
pub fn de_put_role_permissions_boundary_http_response(
  105     90   
    _response_status: u16,
  106     91   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +114,99 @@
   20     20   
        "LimitExceeded" => crate::operation::put_role_policy::PutRolePolicyError::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::put_role_policy::PutRolePolicyError::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   
        "MalformedPolicyDocument" => crate::operation::put_role_policy::PutRolePolicyError::MalformedPolicyDocumentException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::MalformedPolicyDocumentExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_malformed_policy_document_exception::de_malformed_policy_document_exception_xml_err(
   41     38   
                    _response_body,
   42     39   
                    output,
   43     40   
                )
   44     41   
                .map_err(crate::operation::put_role_policy::PutRolePolicyError::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::put_role_policy::PutRolePolicyError::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::put_role_policy::PutRolePolicyError::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::put_role_policy::PutRolePolicyError::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::put_role_policy::PutRolePolicyError::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   
        "UnmodifiableEntity" => crate::operation::put_role_policy::PutRolePolicyError::UnmodifiableEntityException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::UnmodifiableEntityExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_unmodifiable_entity_exception::de_unmodifiable_entity_exception_xml_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::put_role_policy::PutRolePolicyError::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::put_role_policy::PutRolePolicyError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_put_role_policy_http_response(
  104     89   
    _response_status: u16,
  105     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +103,91 @@
   23     23   
        "InvalidInput" => crate::operation::put_user_permissions_boundary::PutUserPermissionsBoundaryError::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::put_user_permissions_boundary::PutUserPermissionsBoundaryError::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::put_user_permissions_boundary::PutUserPermissionsBoundaryError::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::put_user_permissions_boundary::PutUserPermissionsBoundaryError::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   
        "PolicyNotAttachable" => crate::operation::put_user_permissions_boundary::PutUserPermissionsBoundaryError::PolicyNotAttachableException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::PolicyNotAttachableExceptionBuilder::default();
   58     52   
                output =
   59     53   
                    crate::protocol_serde::shape_policy_not_attachable_exception::de_policy_not_attachable_exception_xml_err(_response_body, output)
   60     54   
                        .map_err(crate::operation::put_user_permissions_boundary::PutUserPermissionsBoundaryError::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   
        "ServiceFailure" => crate::operation::put_user_permissions_boundary::PutUserPermissionsBoundaryError::ServiceFailureException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::put_user_permissions_boundary::PutUserPermissionsBoundaryError::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   
        _ => crate::operation::put_user_permissions_boundary::PutUserPermissionsBoundaryError::generic(generic),
   85     73   
    })
   86     74   
}
   87     75   
   88     76   
#[allow(clippy::unnecessary_wraps)]
   89     77   
pub fn de_put_user_permissions_boundary_http_response(
   90     78   
    _response_status: u16,
   91     79   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +99,87 @@
   20     20   
        "LimitExceeded" => crate::operation::put_user_policy::PutUserPolicyError::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::put_user_policy::PutUserPolicyError::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   
        "MalformedPolicyDocument" => crate::operation::put_user_policy::PutUserPolicyError::MalformedPolicyDocumentException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::MalformedPolicyDocumentExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_malformed_policy_document_exception::de_malformed_policy_document_exception_xml_err(
   41     38   
                    _response_body,
   42     39   
                    output,
   43     40   
                )
   44     41   
                .map_err(crate::operation::put_user_policy::PutUserPolicyError::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::put_user_policy::PutUserPolicyError::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::put_user_policy::PutUserPolicyError::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::put_user_policy::PutUserPolicyError::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::put_user_policy::PutUserPolicyError::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::put_user_policy::PutUserPolicyError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_put_user_policy_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_remove_client_id_from_open_id_connect_provider.rs

@@ -10,10 +105,96 @@
   30     30   
                let mut tmp = {
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidInputExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_input_exception::de_invalid_input_exception_xml_err(_response_body, output)
   34     34   
                        .map_err(
   35     35   
                            crate::operation::remove_client_id_from_open_id_connect_provider::RemoveClientIDFromOpenIDConnectProviderError::unhandled,
   36     36   
                        )?;
   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   
        }
   46     43   
        "NoSuchEntity" => {
   47     44   
            crate::operation::remove_client_id_from_open_id_connect_provider::RemoveClientIDFromOpenIDConnectProviderError::NoSuchEntityException({
   48     45   
                #[allow(unused_mut)]
   49     46   
                let mut tmp = {
   50     47   
                    #[allow(unused_mut)]
   51     48   
                    let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   52     49   
                    output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   53     50   
                        .map_err(
   54     51   
                            crate::operation::remove_client_id_from_open_id_connect_provider::RemoveClientIDFromOpenIDConnectProviderError::unhandled,
   55     52   
                        )?;
   56     53   
                    let output = output.meta(generic);
   57     54   
                    output.build()
   58     55   
                };
   59         -
                if tmp.message.is_none() {
   60         -
                    tmp.message = _error_message;
   61         -
                }
   62     56   
                tmp
   63     57   
            })
   64     58   
        }
   65     59   
        "ServiceFailure" => {
   66     60   
            crate::operation::remove_client_id_from_open_id_connect_provider::RemoveClientIDFromOpenIDConnectProviderError::ServiceFailureException({
   67     61   
                #[allow(unused_mut)]
   68     62   
                let mut tmp = {
   69     63   
                    #[allow(unused_mut)]
   70     64   
                    let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   71     65   
                    output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   72     66   
                        .map_err(
   73     67   
                            crate::operation::remove_client_id_from_open_id_connect_provider::RemoveClientIDFromOpenIDConnectProviderError::unhandled,
   74     68   
                        )?;
   75     69   
                    let output = output.meta(generic);
   76     70   
                    output.build()
   77     71   
                };
   78         -
                if tmp.message.is_none() {
   79         -
                    tmp.message = _error_message;
   80         -
                }
   81     72   
                tmp
   82     73   
            })
   83     74   
        }
   84     75   
        _ => crate::operation::remove_client_id_from_open_id_connect_provider::RemoveClientIDFromOpenIDConnectProviderError::generic(generic),
   85     76   
    })
   86     77   
}
   87     78   
   88     79   
#[allow(clippy::unnecessary_wraps)]
   89     80   
pub fn de_remove_client_id_from_open_id_connect_provider_http_response(
   90     81   
    _response_status: u16,