AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05 (ignoring whitespace)

Files changed:

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

@@ -3,3 +110,98 @@
   23     23   
        "InvalidInput" => crate::operation::update_saml_provider::UpdateSAMLProviderError::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::update_saml_provider::UpdateSAMLProviderError::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::update_saml_provider::UpdateSAMLProviderError::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::update_saml_provider::UpdateSAMLProviderError::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::update_saml_provider::UpdateSAMLProviderError::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::update_saml_provider::UpdateSAMLProviderError::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::update_saml_provider::UpdateSAMLProviderError::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::update_saml_provider::UpdateSAMLProviderError::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::update_saml_provider::UpdateSAMLProviderError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_update_saml_provider_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_update_server_certificate.rs

@@ -8,8 +107,95 @@
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::EntityAlreadyExistsExceptionBuilder::default();
   32     32   
                output =
   33     33   
                    crate::protocol_serde::shape_entity_already_exists_exception::de_entity_already_exists_exception_xml_err(_response_body, output)
   34     34   
                        .map_err(crate::operation::update_server_certificate::UpdateServerCertificateError::unhandled)?;
   35     35   
                let output = output.meta(generic);
   36     36   
                output.build()
   37     37   
            };
   38         -
            if tmp.message.is_none() {
   39         -
                tmp.message = _error_message;
   40         -
            }
   41     38   
            tmp
   42     39   
        }),
   43     40   
        "LimitExceeded" => crate::operation::update_server_certificate::UpdateServerCertificateError::LimitExceededException({
   44     41   
            #[allow(unused_mut)]
   45     42   
            let mut tmp = {
   46     43   
                #[allow(unused_mut)]
   47     44   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   48     45   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   49     46   
                    .map_err(crate::operation::update_server_certificate::UpdateServerCertificateError::unhandled)?;
   50     47   
                let output = output.meta(generic);
   51     48   
                output.build()
   52     49   
            };
   53         -
            if tmp.message.is_none() {
   54         -
                tmp.message = _error_message;
   55         -
            }
   56     50   
            tmp
   57     51   
        }),
   58     52   
        "NoSuchEntity" => crate::operation::update_server_certificate::UpdateServerCertificateError::NoSuchEntityException({
   59     53   
            #[allow(unused_mut)]
   60     54   
            let mut tmp = {
   61     55   
                #[allow(unused_mut)]
   62     56   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   63     57   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   64     58   
                    .map_err(crate::operation::update_server_certificate::UpdateServerCertificateError::unhandled)?;
   65     59   
                let output = output.meta(generic);
   66     60   
                output.build()
   67     61   
            };
   68         -
            if tmp.message.is_none() {
   69         -
                tmp.message = _error_message;
   70         -
            }
   71     62   
            tmp
   72     63   
        }),
   73     64   
        "ServiceFailure" => crate::operation::update_server_certificate::UpdateServerCertificateError::ServiceFailureException({
   74     65   
            #[allow(unused_mut)]
   75     66   
            let mut tmp = {
   76     67   
                #[allow(unused_mut)]
   77     68   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   78     69   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
   79     70   
                    .map_err(crate::operation::update_server_certificate::UpdateServerCertificateError::unhandled)?;
   80     71   
                let output = output.meta(generic);
   81     72   
                output.build()
   82     73   
            };
   83         -
            if tmp.message.is_none() {
   84         -
                tmp.message = _error_message;
   85         -
            }
   86     74   
            tmp
   87     75   
        }),
   88     76   
        _ => crate::operation::update_server_certificate::UpdateServerCertificateError::generic(generic),
   89     77   
    })
   90     78   
}
   91     79   
   92     80   
#[allow(clippy::unnecessary_wraps)]
   93     81   
pub fn de_update_server_certificate_http_response(
   94     82   
    _response_status: u16,
   95     83   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +57,54 @@
   23     23   
        "NoSuchEntity" => crate::operation::update_service_specific_credential::UpdateServiceSpecificCredentialError::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::update_service_specific_credential::UpdateServiceSpecificCredentialError::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::update_service_specific_credential::UpdateServiceSpecificCredentialError::generic(generic),
   39     36   
    })
   40     37   
}
   41     38   
   42     39   
#[allow(clippy::unnecessary_wraps)]
   43     40   
pub fn de_update_service_specific_credential_http_response(
   44     41   
    _response_status: u16,
   45     42   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

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

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

@@ -3,3 +57,54 @@
   23     23   
        "NoSuchEntity" => crate::operation::update_ssh_public_key::UpdateSSHPublicKeyError::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::update_ssh_public_key::UpdateSSHPublicKeyError::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::update_ssh_public_key::UpdateSSHPublicKeyError::generic(generic),
   39     36   
    })
   40     37   
}
   41     38   
   42     39   
#[allow(clippy::unnecessary_wraps)]
   43     40   
pub fn de_update_ssh_public_key_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_update_user.rs

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

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

@@ -10,10 +164,143 @@
   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::upload_server_certificate::UploadServerCertificateError::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::upload_server_certificate::UploadServerCertificateError::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::upload_server_certificate::UploadServerCertificateError::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::upload_server_certificate::UploadServerCertificateError::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::upload_server_certificate::UploadServerCertificateError::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   
        "KeyPairMismatch" => crate::operation::upload_server_certificate::UploadServerCertificateError::KeyPairMismatchException({
   77     68   
            #[allow(unused_mut)]
   78     69   
            let mut tmp = {
   79     70   
                #[allow(unused_mut)]
   80     71   
                let mut output = crate::types::error::builders::KeyPairMismatchExceptionBuilder::default();
   81     72   
                output = crate::protocol_serde::shape_key_pair_mismatch_exception::de_key_pair_mismatch_exception_xml_err(_response_body, output)
   82     73   
                    .map_err(crate::operation::upload_server_certificate::UploadServerCertificateError::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   
        "LimitExceeded" => crate::operation::upload_server_certificate::UploadServerCertificateError::LimitExceededException({
   92     80   
            #[allow(unused_mut)]
   93     81   
            let mut tmp = {
   94     82   
                #[allow(unused_mut)]
   95     83   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   96     84   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   97     85   
                    .map_err(crate::operation::upload_server_certificate::UploadServerCertificateError::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   
        "MalformedCertificate" => crate::operation::upload_server_certificate::UploadServerCertificateError::MalformedCertificateException({
  107     92   
            #[allow(unused_mut)]
  108     93   
            let mut tmp = {
  109     94   
                #[allow(unused_mut)]
  110     95   
                let mut output = crate::types::error::builders::MalformedCertificateExceptionBuilder::default();
  111     96   
                output =
  112     97   
                    crate::protocol_serde::shape_malformed_certificate_exception::de_malformed_certificate_exception_xml_err(_response_body, output)
  113     98   
                        .map_err(crate::operation::upload_server_certificate::UploadServerCertificateError::unhandled)?;
  114     99   
                let output = output.meta(generic);
  115    100   
                output.build()
  116    101   
            };
  117         -
            if tmp.message.is_none() {
  118         -
                tmp.message = _error_message;
  119         -
            }
  120    102   
            tmp
  121    103   
        }),
  122    104   
        "ServiceFailure" => crate::operation::upload_server_certificate::UploadServerCertificateError::ServiceFailureException({
  123    105   
            #[allow(unused_mut)]
  124    106   
            let mut tmp = {
  125    107   
                #[allow(unused_mut)]
  126    108   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
  127    109   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
  128    110   
                    .map_err(crate::operation::upload_server_certificate::UploadServerCertificateError::unhandled)?;
  129    111   
                let output = output.meta(generic);
  130    112   
                output.build()
  131    113   
            };
  132         -
            if tmp.message.is_none() {
  133         -
                tmp.message = _error_message;
  134         -
            }
  135    114   
            tmp
  136    115   
        }),
  137    116   
        _ => crate::operation::upload_server_certificate::UploadServerCertificateError::generic(generic),
  138    117   
    })
  139    118   
}
  140    119   
  141    120   
#[allow(clippy::unnecessary_wraps)]
  142    121   
pub fn de_upload_server_certificate_http_response(
  143    122   
    _response_status: u16,
  144    123   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -10,10 +180,156 @@
   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::upload_signing_certificate::UploadSigningCertificateError::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   
        "DuplicateCertificate" => crate::operation::upload_signing_certificate::UploadSigningCertificateError::DuplicateCertificateException({
   46     43   
            #[allow(unused_mut)]
   47     44   
            let mut tmp = {
   48     45   
                #[allow(unused_mut)]
   49     46   
                let mut output = crate::types::error::builders::DuplicateCertificateExceptionBuilder::default();
   50     47   
                output =
   51     48   
                    crate::protocol_serde::shape_duplicate_certificate_exception::de_duplicate_certificate_exception_xml_err(_response_body, output)
   52     49   
                        .map_err(crate::operation::upload_signing_certificate::UploadSigningCertificateError::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   
        "EntityAlreadyExists" => crate::operation::upload_signing_certificate::UploadSigningCertificateError::EntityAlreadyExistsException({
   62     56   
            #[allow(unused_mut)]
   63     57   
            let mut tmp = {
   64     58   
                #[allow(unused_mut)]
   65     59   
                let mut output = crate::types::error::builders::EntityAlreadyExistsExceptionBuilder::default();
   66     60   
                output =
   67     61   
                    crate::protocol_serde::shape_entity_already_exists_exception::de_entity_already_exists_exception_xml_err(_response_body, output)
   68     62   
                        .map_err(crate::operation::upload_signing_certificate::UploadSigningCertificateError::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   
        "InvalidCertificate" => crate::operation::upload_signing_certificate::UploadSigningCertificateError::InvalidCertificateException({
   78     69   
            #[allow(unused_mut)]
   79     70   
            let mut tmp = {
   80     71   
                #[allow(unused_mut)]
   81     72   
                let mut output = crate::types::error::builders::InvalidCertificateExceptionBuilder::default();
   82     73   
                output = crate::protocol_serde::shape_invalid_certificate_exception::de_invalid_certificate_exception_xml_err(_response_body, output)
   83     74   
                    .map_err(crate::operation::upload_signing_certificate::UploadSigningCertificateError::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   
        "LimitExceeded" => crate::operation::upload_signing_certificate::UploadSigningCertificateError::LimitExceededException({
   93     81   
            #[allow(unused_mut)]
   94     82   
            let mut tmp = {
   95     83   
                #[allow(unused_mut)]
   96     84   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   97     85   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   98     86   
                    .map_err(crate::operation::upload_signing_certificate::UploadSigningCertificateError::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   
        "MalformedCertificate" => crate::operation::upload_signing_certificate::UploadSigningCertificateError::MalformedCertificateException({
  108     93   
            #[allow(unused_mut)]
  109     94   
            let mut tmp = {
  110     95   
                #[allow(unused_mut)]
  111     96   
                let mut output = crate::types::error::builders::MalformedCertificateExceptionBuilder::default();
  112     97   
                output =
  113     98   
                    crate::protocol_serde::shape_malformed_certificate_exception::de_malformed_certificate_exception_xml_err(_response_body, output)
  114     99   
                        .map_err(crate::operation::upload_signing_certificate::UploadSigningCertificateError::unhandled)?;
  115    100   
                let output = output.meta(generic);
  116    101   
                output.build()
  117    102   
            };
  118         -
            if tmp.message.is_none() {
  119         -
                tmp.message = _error_message;
  120         -
            }
  121    103   
            tmp
  122    104   
        }),
  123    105   
        "NoSuchEntity" => crate::operation::upload_signing_certificate::UploadSigningCertificateError::NoSuchEntityException({
  124    106   
            #[allow(unused_mut)]
  125    107   
            let mut tmp = {
  126    108   
                #[allow(unused_mut)]
  127    109   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
  128    110   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
  129    111   
                    .map_err(crate::operation::upload_signing_certificate::UploadSigningCertificateError::unhandled)?;
  130    112   
                let output = output.meta(generic);
  131    113   
                output.build()
  132    114   
            };
  133         -
            if tmp.message.is_none() {
  134         -
                tmp.message = _error_message;
  135         -
            }
  136    115   
            tmp
  137    116   
        }),
  138    117   
        "ServiceFailure" => crate::operation::upload_signing_certificate::UploadSigningCertificateError::ServiceFailureException({
  139    118   
            #[allow(unused_mut)]
  140    119   
            let mut tmp = {
  141    120   
                #[allow(unused_mut)]
  142    121   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
  143    122   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_xml_err(_response_body, output)
  144    123   
                    .map_err(crate::operation::upload_signing_certificate::UploadSigningCertificateError::unhandled)?;
  145    124   
                let output = output.meta(generic);
  146    125   
                output.build()
  147    126   
            };
  148         -
            if tmp.message.is_none() {
  149         -
                tmp.message = _error_message;
  150         -
            }
  151    127   
            tmp
  152    128   
        }),
  153    129   
        _ => crate::operation::upload_signing_certificate::UploadSigningCertificateError::generic(generic),
  154    130   
    })
  155    131   
}
  156    132   
  157    133   
#[allow(clippy::unnecessary_wraps)]
  158    134   
pub fn de_upload_signing_certificate_http_response(
  159    135   
    _response_status: u16,
  160    136   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -6,6 +128,113 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::DuplicateSshPublicKeyExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_duplicate_ssh_public_key_exception::de_duplicate_ssh_public_key_exception_xml_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::upload_ssh_public_key::UploadSSHPublicKeyError::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   
        "InvalidPublicKey" => crate::operation::upload_ssh_public_key::UploadSSHPublicKeyError::InvalidPublicKeyException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::InvalidPublicKeyExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_invalid_public_key_exception::de_invalid_public_key_exception_xml_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::upload_ssh_public_key::UploadSSHPublicKeyError::unhandled)?;
   48     45   
                let output = output.meta(generic);
   49     46   
                output.build()
   50     47   
            };
   51         -
            if tmp.message.is_none() {
   52         -
                tmp.message = _error_message;
   53         -
            }
   54     48   
            tmp
   55     49   
        }),
   56     50   
        "LimitExceeded" => crate::operation::upload_ssh_public_key::UploadSSHPublicKeyError::LimitExceededException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_xml_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::upload_ssh_public_key::UploadSSHPublicKeyError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "NoSuchEntity" => crate::operation::upload_ssh_public_key::UploadSSHPublicKeyError::NoSuchEntityException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::NoSuchEntityExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_no_such_entity_exception::de_no_such_entity_exception_xml_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::upload_ssh_public_key::UploadSSHPublicKeyError::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   
        "UnrecognizedPublicKeyEncoding" => {
   87     75   
            crate::operation::upload_ssh_public_key::UploadSSHPublicKeyError::UnrecognizedPublicKeyEncodingException({
   88     76   
                #[allow(unused_mut)]
   89     77   
                let mut tmp = {
   90     78   
                    #[allow(unused_mut)]
   91     79   
                    let mut output = crate::types::error::builders::UnrecognizedPublicKeyEncodingExceptionBuilder::default();
   92     80   
                    output = crate::protocol_serde::shape_unrecognized_public_key_encoding_exception::de_unrecognized_public_key_encoding_exception_xml_err(_response_body, output).map_err(crate::operation::upload_ssh_public_key::UploadSSHPublicKeyError::unhandled)?;
   93     81   
                    let output = output.meta(generic);
   94     82   
                    output.build()
   95     83   
                };
   96         -
                if tmp.message.is_none() {
   97         -
                    tmp.message = _error_message;
   98         -
                }
   99     84   
                tmp
  100     85   
            })
  101     86   
        }
  102     87   
        _ => crate::operation::upload_ssh_public_key::UploadSSHPublicKeyError::generic(generic),
  103     88   
    })
  104     89   
}
  105     90   
  106     91   
#[allow(clippy::unnecessary_wraps)]
  107     92   
pub fn de_upload_ssh_public_key_http_response(
  108     93   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/kms/src/protocol_serde/shape_cancel_key_deletion.rs

@@ -1,1 +123,108 @@
   21     21   
        "DependencyTimeoutException" => crate::operation::cancel_key_deletion::CancelKeyDeletionError::DependencyTimeoutException({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::DependencyTimeoutExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_dependency_timeout_exception::de_dependency_timeout_exception_json_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::cancel_key_deletion::CancelKeyDeletionError::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   
        "InvalidArnException" => crate::operation::cancel_key_deletion::CancelKeyDeletionError::InvalidArnException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::cancel_key_deletion::CancelKeyDeletionError::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   
        "KMSInternalException" => crate::operation::cancel_key_deletion::CancelKeyDeletionError::KmsInternalException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::cancel_key_deletion::CancelKeyDeletionError::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   
        "KMSInvalidStateException" => crate::operation::cancel_key_deletion::CancelKeyDeletionError::KmsInvalidStateException({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::cancel_key_deletion::CancelKeyDeletionError::unhandled)?;
   73     64   
                let output = output.meta(generic);
   74     65   
                output.build()
   75     66   
            };
   76         -
            if tmp.message.is_none() {
   77         -
                tmp.message = _error_message;
   78         -
            }
   79     67   
            tmp
   80     68   
        }),
   81     69   
        "NotFoundException" => crate::operation::cancel_key_deletion::CancelKeyDeletionError::NotFoundException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
   87     75   
                    .map_err(crate::operation::cancel_key_deletion::CancelKeyDeletionError::unhandled)?;
   88     76   
                let output = output.meta(generic);
   89     77   
                output.build()
   90     78   
            };
   91         -
            if tmp.message.is_none() {
   92         -
                tmp.message = _error_message;
   93         -
            }
   94     79   
            tmp
   95     80   
        }),
   96     81   
        _ => crate::operation::cancel_key_deletion::CancelKeyDeletionError::generic(generic),
   97     82   
    })
   98     83   
}
   99     84   
  100     85   
#[allow(clippy::unnecessary_wraps)]
  101     86   
pub fn de_cancel_key_deletion_http_response(
  102     87   
    _response_status: u16,
  103     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/kms/src/protocol_serde/shape_connect_custom_key_store.rs

@@ -3,3 +142,127 @@
   23     23   
        "CloudHsmClusterInvalidConfigurationException" => {
   24     24   
            crate::operation::connect_custom_key_store::ConnectCustomKeyStoreError::CloudHsmClusterInvalidConfigurationException({
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::CloudHsmClusterInvalidConfigurationExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_cloud_hsm_cluster_invalid_configuration_exception::de_cloud_hsm_cluster_invalid_configuration_exception_json_err(_response_body, output).map_err(crate::operation::connect_custom_key_store::ConnectCustomKeyStoreError::unhandled)?;
   30     30   
                    let output = output.meta(generic);
   31     31   
                    output.build()
   32     32   
                };
   33         -
                if tmp.message.is_none() {
   34         -
                    tmp.message = _error_message;
   35         -
                }
   36     33   
                tmp
   37     34   
            })
   38     35   
        }
   39     36   
        "CloudHsmClusterNotActiveException" => {
   40     37   
            crate::operation::connect_custom_key_store::ConnectCustomKeyStoreError::CloudHsmClusterNotActiveException({
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut tmp = {
   43     40   
                    #[allow(unused_mut)]
   44     41   
                    let mut output = crate::types::error::builders::CloudHsmClusterNotActiveExceptionBuilder::default();
   45     42   
                    output = crate::protocol_serde::shape_cloud_hsm_cluster_not_active_exception::de_cloud_hsm_cluster_not_active_exception_json_err(
   46     43   
                        _response_body,
   47     44   
                        output,
   48     45   
                    )
   49     46   
                    .map_err(crate::operation::connect_custom_key_store::ConnectCustomKeyStoreError::unhandled)?;
   50     47   
                    let output = output.meta(generic);
   51     48   
                    output.build()
   52     49   
                };
   53         -
                if tmp.message.is_none() {
   54         -
                    tmp.message = _error_message;
   55         -
                }
   56     50   
                tmp
   57     51   
            })
   58     52   
        }
   59     53   
        "CustomKeyStoreInvalidStateException" => {
   60     54   
            crate::operation::connect_custom_key_store::ConnectCustomKeyStoreError::CustomKeyStoreInvalidStateException({
   61     55   
                #[allow(unused_mut)]
   62     56   
                let mut tmp = {
   63     57   
                    #[allow(unused_mut)]
   64     58   
                    let mut output = crate::types::error::builders::CustomKeyStoreInvalidStateExceptionBuilder::default();
   65     59   
                    output =
   66     60   
                        crate::protocol_serde::shape_custom_key_store_invalid_state_exception::de_custom_key_store_invalid_state_exception_json_err(
   67     61   
                            _response_body,
   68     62   
                            output,
   69     63   
                        )
   70     64   
                        .map_err(crate::operation::connect_custom_key_store::ConnectCustomKeyStoreError::unhandled)?;
   71     65   
                    let output = output.meta(generic);
   72     66   
                    output.build()
   73     67   
                };
   74         -
                if tmp.message.is_none() {
   75         -
                    tmp.message = _error_message;
   76         -
                }
   77     68   
                tmp
   78     69   
            })
   79     70   
        }
   80     71   
        "CustomKeyStoreNotFoundException" => {
   81     72   
            crate::operation::connect_custom_key_store::ConnectCustomKeyStoreError::CustomKeyStoreNotFoundException({
   82     73   
                #[allow(unused_mut)]
   83     74   
                let mut tmp = {
   84     75   
                    #[allow(unused_mut)]
   85     76   
                    let mut output = crate::types::error::builders::CustomKeyStoreNotFoundExceptionBuilder::default();
   86     77   
                    output = crate::protocol_serde::shape_custom_key_store_not_found_exception::de_custom_key_store_not_found_exception_json_err(
   87     78   
                        _response_body,
   88     79   
                        output,
   89     80   
                    )
   90     81   
                    .map_err(crate::operation::connect_custom_key_store::ConnectCustomKeyStoreError::unhandled)?;
   91     82   
                    let output = output.meta(generic);
   92     83   
                    output.build()
   93     84   
                };
   94         -
                if tmp.message.is_none() {
   95         -
                    tmp.message = _error_message;
   96         -
                }
   97     85   
                tmp
   98     86   
            })
   99     87   
        }
  100     88   
        "KMSInternalException" => crate::operation::connect_custom_key_store::ConnectCustomKeyStoreError::KmsInternalException({
  101     89   
            #[allow(unused_mut)]
  102     90   
            let mut tmp = {
  103     91   
                #[allow(unused_mut)]
  104     92   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
  105     93   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
  106     94   
                    .map_err(crate::operation::connect_custom_key_store::ConnectCustomKeyStoreError::unhandled)?;
  107     95   
                let output = output.meta(generic);
  108     96   
                output.build()
  109     97   
            };
  110         -
            if tmp.message.is_none() {
  111         -
                tmp.message = _error_message;
  112         -
            }
  113     98   
            tmp
  114     99   
        }),
  115    100   
        _ => crate::operation::connect_custom_key_store::ConnectCustomKeyStoreError::generic(generic),
  116    101   
    })
  117    102   
}
  118    103   
  119    104   
#[allow(clippy::unnecessary_wraps)]
  120    105   
pub fn de_connect_custom_key_store_http_response(
  121    106   
    _response_status: u16,
  122    107   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/kms/src/protocol_serde/shape_create_alias.rs

@@ -1,1 +151,130 @@
   20     20   
        "AlreadyExistsException" => crate::operation::create_alias::CreateAliasError::AlreadyExistsException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::AlreadyExistsExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_already_exists_exception::de_already_exists_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::create_alias::CreateAliasError::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   
        "DependencyTimeoutException" => crate::operation::create_alias::CreateAliasError::DependencyTimeoutException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::DependencyTimeoutExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_dependency_timeout_exception::de_dependency_timeout_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::create_alias::CreateAliasError::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   
        "InvalidAliasNameException" => crate::operation::create_alias::CreateAliasError::InvalidAliasNameException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidAliasNameExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_alias_name_exception::de_invalid_alias_name_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::create_alias::CreateAliasError::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   
        "KMSInternalException" => crate::operation::create_alias::CreateAliasError::KmsInternalException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::create_alias::CreateAliasError::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   
        "KMSInvalidStateException" => crate::operation::create_alias::CreateAliasError::KmsInvalidStateException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::create_alias::CreateAliasError::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   
        "LimitExceededException" => crate::operation::create_alias::CreateAliasError::LimitExceededException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
  100     85   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
  101     86   
                    .map_err(crate::operation::create_alias::CreateAliasError::unhandled)?;
  102     87   
                let output = output.meta(generic);
  103     88   
                output.build()
  104     89   
            };
  105         -
            if tmp.message.is_none() {
  106         -
                tmp.message = _error_message;
  107         -
            }
  108     90   
            tmp
  109     91   
        }),
  110     92   
        "NotFoundException" => crate::operation::create_alias::CreateAliasError::NotFoundException({
  111     93   
            #[allow(unused_mut)]
  112     94   
            let mut tmp = {
  113     95   
                #[allow(unused_mut)]
  114     96   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
  115     97   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
  116     98   
                    .map_err(crate::operation::create_alias::CreateAliasError::unhandled)?;
  117     99   
                let output = output.meta(generic);
  118    100   
                output.build()
  119    101   
            };
  120         -
            if tmp.message.is_none() {
  121         -
                tmp.message = _error_message;
  122         -
            }
  123    102   
            tmp
  124    103   
        }),
  125    104   
        _ => crate::operation::create_alias::CreateAliasError::generic(generic),
  126    105   
    })
  127    106   
}
  128    107   
  129    108   
#[allow(clippy::unnecessary_wraps)]
  130    109   
pub fn de_create_alias_http_response(
  131    110   
    _response_status: u16,
  132    111   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/kms/src/protocol_serde/shape_create_custom_key_store.rs

@@ -6,6 +346,295 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::CloudHsmClusterInUseExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_cloud_hsm_cluster_in_use_exception::de_cloud_hsm_cluster_in_use_exception_json_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::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   
        "CloudHsmClusterInvalidConfigurationException" => {
   42     39   
            crate::operation::create_custom_key_store::CreateCustomKeyStoreError::CloudHsmClusterInvalidConfigurationException({
   43     40   
                #[allow(unused_mut)]
   44     41   
                let mut tmp = {
   45     42   
                    #[allow(unused_mut)]
   46     43   
                    let mut output = crate::types::error::builders::CloudHsmClusterInvalidConfigurationExceptionBuilder::default();
   47     44   
                    output = crate::protocol_serde::shape_cloud_hsm_cluster_invalid_configuration_exception::de_cloud_hsm_cluster_invalid_configuration_exception_json_err(_response_body, output).map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::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   
        }
   57     51   
        "CloudHsmClusterNotActiveException" => {
   58     52   
            crate::operation::create_custom_key_store::CreateCustomKeyStoreError::CloudHsmClusterNotActiveException({
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut tmp = {
   61     55   
                    #[allow(unused_mut)]
   62     56   
                    let mut output = crate::types::error::builders::CloudHsmClusterNotActiveExceptionBuilder::default();
   63     57   
                    output = crate::protocol_serde::shape_cloud_hsm_cluster_not_active_exception::de_cloud_hsm_cluster_not_active_exception_json_err(
   64     58   
                        _response_body,
   65     59   
                        output,
   66     60   
                    )
   67     61   
                    .map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::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   
        }
   77     68   
        "CloudHsmClusterNotFoundException" => {
   78     69   
            crate::operation::create_custom_key_store::CreateCustomKeyStoreError::CloudHsmClusterNotFoundException({
   79     70   
                #[allow(unused_mut)]
   80     71   
                let mut tmp = {
   81     72   
                    #[allow(unused_mut)]
   82     73   
                    let mut output = crate::types::error::builders::CloudHsmClusterNotFoundExceptionBuilder::default();
   83     74   
                    output = crate::protocol_serde::shape_cloud_hsm_cluster_not_found_exception::de_cloud_hsm_cluster_not_found_exception_json_err(
   84     75   
                        _response_body,
   85     76   
                        output,
   86     77   
                    )
   87     78   
                    .map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
   88     79   
                    let output = output.meta(generic);
   89     80   
                    output.build()
   90     81   
                };
   91         -
                if tmp.message.is_none() {
   92         -
                    tmp.message = _error_message;
   93         -
                }
   94     82   
                tmp
   95     83   
            })
   96     84   
        }
   97     85   
        "CustomKeyStoreNameInUseException" => {
   98     86   
            crate::operation::create_custom_key_store::CreateCustomKeyStoreError::CustomKeyStoreNameInUseException({
   99     87   
                #[allow(unused_mut)]
  100     88   
                let mut tmp = {
  101     89   
                    #[allow(unused_mut)]
  102     90   
                    let mut output = crate::types::error::builders::CustomKeyStoreNameInUseExceptionBuilder::default();
  103     91   
                    output = crate::protocol_serde::shape_custom_key_store_name_in_use_exception::de_custom_key_store_name_in_use_exception_json_err(
  104     92   
                        _response_body,
  105     93   
                        output,
  106     94   
                    )
  107     95   
                    .map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
  108     96   
                    let output = output.meta(generic);
  109     97   
                    output.build()
  110     98   
                };
  111         -
                if tmp.message.is_none() {
  112         -
                    tmp.message = _error_message;
  113         -
                }
  114     99   
                tmp
  115    100   
            })
  116    101   
        }
  117    102   
        "IncorrectTrustAnchorException" => crate::operation::create_custom_key_store::CreateCustomKeyStoreError::IncorrectTrustAnchorException({
  118    103   
            #[allow(unused_mut)]
  119    104   
            let mut tmp = {
  120    105   
                #[allow(unused_mut)]
  121    106   
                let mut output = crate::types::error::builders::IncorrectTrustAnchorExceptionBuilder::default();
  122    107   
                output = crate::protocol_serde::shape_incorrect_trust_anchor_exception::de_incorrect_trust_anchor_exception_json_err(
  123    108   
                    _response_body,
  124    109   
                    output,
  125    110   
                )
  126    111   
                .map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
  127    112   
                let output = output.meta(generic);
  128    113   
                output.build()
  129    114   
            };
  130         -
            if tmp.message.is_none() {
  131         -
                tmp.message = _error_message;
  132         -
            }
  133    115   
            tmp
  134    116   
        }),
  135    117   
        "KMSInternalException" => crate::operation::create_custom_key_store::CreateCustomKeyStoreError::KmsInternalException({
  136    118   
            #[allow(unused_mut)]
  137    119   
            let mut tmp = {
  138    120   
                #[allow(unused_mut)]
  139    121   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
  140    122   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
  141    123   
                    .map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
  142    124   
                let output = output.meta(generic);
  143    125   
                output.build()
  144    126   
            };
  145         -
            if tmp.message.is_none() {
  146         -
                tmp.message = _error_message;
  147         -
            }
  148    127   
            tmp
  149    128   
        }),
  150    129   
        "LimitExceededException" => crate::operation::create_custom_key_store::CreateCustomKeyStoreError::LimitExceededException({
  151    130   
            #[allow(unused_mut)]
  152    131   
            let mut tmp = {
  153    132   
                #[allow(unused_mut)]
  154    133   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
  155    134   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
  156    135   
                    .map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
  157    136   
                let output = output.meta(generic);
  158    137   
                output.build()
  159    138   
            };
  160         -
            if tmp.message.is_none() {
  161         -
                tmp.message = _error_message;
  162         -
            }
  163    139   
            tmp
  164    140   
        }),
  165    141   
        "XksProxyIncorrectAuthenticationCredentialException" => {
  166    142   
            crate::operation::create_custom_key_store::CreateCustomKeyStoreError::XksProxyIncorrectAuthenticationCredentialException({
  167    143   
                #[allow(unused_mut)]
  168    144   
                let mut tmp = {
  169    145   
                    #[allow(unused_mut)]
  170    146   
                    let mut output = crate::types::error::builders::XksProxyIncorrectAuthenticationCredentialExceptionBuilder::default();
  171    147   
                    output = crate::protocol_serde::shape_xks_proxy_incorrect_authentication_credential_exception::de_xks_proxy_incorrect_authentication_credential_exception_json_err(_response_body, output).map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
  172    148   
                    let output = output.meta(generic);
  173    149   
                    output.build()
  174    150   
                };
  175         -
                if tmp.message.is_none() {
  176         -
                    tmp.message = _error_message;
  177         -
                }
  178    151   
                tmp
  179    152   
            })
  180    153   
        }
  181    154   
        "XksProxyInvalidConfigurationException" => {
  182    155   
            crate::operation::create_custom_key_store::CreateCustomKeyStoreError::XksProxyInvalidConfigurationException({
  183    156   
                #[allow(unused_mut)]
  184    157   
                let mut tmp = {
  185    158   
                    #[allow(unused_mut)]
  186    159   
                    let mut output = crate::types::error::builders::XksProxyInvalidConfigurationExceptionBuilder::default();
  187    160   
                    output = crate::protocol_serde::shape_xks_proxy_invalid_configuration_exception::de_xks_proxy_invalid_configuration_exception_json_err(_response_body, output).map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
  188    161   
                    let output = output.meta(generic);
  189    162   
                    output.build()
  190    163   
                };
  191         -
                if tmp.message.is_none() {
  192         -
                    tmp.message = _error_message;
  193         -
                }
  194    164   
                tmp
  195    165   
            })
  196    166   
        }
  197    167   
        "XksProxyInvalidResponseException" => {
  198    168   
            crate::operation::create_custom_key_store::CreateCustomKeyStoreError::XksProxyInvalidResponseException({
  199    169   
                #[allow(unused_mut)]
  200    170   
                let mut tmp = {
  201    171   
                    #[allow(unused_mut)]
  202    172   
                    let mut output = crate::types::error::builders::XksProxyInvalidResponseExceptionBuilder::default();
  203    173   
                    output = crate::protocol_serde::shape_xks_proxy_invalid_response_exception::de_xks_proxy_invalid_response_exception_json_err(
  204    174   
                        _response_body,
  205    175   
                        output,
  206    176   
                    )
  207    177   
                    .map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
  208    178   
                    let output = output.meta(generic);
  209    179   
                    output.build()
  210    180   
                };
  211         -
                if tmp.message.is_none() {
  212         -
                    tmp.message = _error_message;
  213         -
                }
  214    181   
                tmp
  215    182   
            })
  216    183   
        }
  217    184   
        "XksProxyUriEndpointInUseException" => {
  218    185   
            crate::operation::create_custom_key_store::CreateCustomKeyStoreError::XksProxyUriEndpointInUseException({
  219    186   
                #[allow(unused_mut)]
  220    187   
                let mut tmp = {
  221    188   
                    #[allow(unused_mut)]
  222    189   
                    let mut output = crate::types::error::builders::XksProxyUriEndpointInUseExceptionBuilder::default();
  223    190   
                    output =
  224    191   
                        crate::protocol_serde::shape_xks_proxy_uri_endpoint_in_use_exception::de_xks_proxy_uri_endpoint_in_use_exception_json_err(
  225    192   
                            _response_body,
  226    193   
                            output,
  227    194   
                        )
  228    195   
                        .map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
  229    196   
                    let output = output.meta(generic);
  230    197   
                    output.build()
  231    198   
                };
  232         -
                if tmp.message.is_none() {
  233         -
                    tmp.message = _error_message;
  234         -
                }
  235    199   
                tmp
  236    200   
            })
  237    201   
        }
  238    202   
        "XksProxyUriInUseException" => crate::operation::create_custom_key_store::CreateCustomKeyStoreError::XksProxyUriInUseException({
  239    203   
            #[allow(unused_mut)]
  240    204   
            let mut tmp = {
  241    205   
                #[allow(unused_mut)]
  242    206   
                let mut output = crate::types::error::builders::XksProxyUriInUseExceptionBuilder::default();
  243    207   
                output =
  244    208   
                    crate::protocol_serde::shape_xks_proxy_uri_in_use_exception::de_xks_proxy_uri_in_use_exception_json_err(_response_body, output)
  245    209   
                        .map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
  246    210   
                let output = output.meta(generic);
  247    211   
                output.build()
  248    212   
            };
  249         -
            if tmp.message.is_none() {
  250         -
                tmp.message = _error_message;
  251         -
            }
  252    213   
            tmp
  253    214   
        }),
  254    215   
        "XksProxyUriUnreachableException" => crate::operation::create_custom_key_store::CreateCustomKeyStoreError::XksProxyUriUnreachableException({
  255    216   
            #[allow(unused_mut)]
  256    217   
            let mut tmp = {
  257    218   
                #[allow(unused_mut)]
  258    219   
                let mut output = crate::types::error::builders::XksProxyUriUnreachableExceptionBuilder::default();
  259    220   
                output = crate::protocol_serde::shape_xks_proxy_uri_unreachable_exception::de_xks_proxy_uri_unreachable_exception_json_err(
  260    221   
                    _response_body,
  261    222   
                    output,
  262    223   
                )
  263    224   
                .map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
  264    225   
                let output = output.meta(generic);
  265    226   
                output.build()
  266    227   
            };
  267         -
            if tmp.message.is_none() {
  268         -
                tmp.message = _error_message;
  269         -
            }
  270    228   
            tmp
  271    229   
        }),
  272    230   
        "XksProxyVpcEndpointServiceInUseException" => {
  273    231   
            crate::operation::create_custom_key_store::CreateCustomKeyStoreError::XksProxyVpcEndpointServiceInUseException({
  274    232   
                #[allow(unused_mut)]
  275    233   
                let mut tmp = {
  276    234   
                    #[allow(unused_mut)]
  277    235   
                    let mut output = crate::types::error::builders::XksProxyVpcEndpointServiceInUseExceptionBuilder::default();
  278    236   
                    output = crate::protocol_serde::shape_xks_proxy_vpc_endpoint_service_in_use_exception::de_xks_proxy_vpc_endpoint_service_in_use_exception_json_err(_response_body, output).map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
  279    237   
                    let output = output.meta(generic);
  280    238   
                    output.build()
  281    239   
                };
  282         -
                if tmp.message.is_none() {
  283         -
                    tmp.message = _error_message;
  284         -
                }
  285    240   
                tmp
  286    241   
            })
  287    242   
        }
  288    243   
        "XksProxyVpcEndpointServiceInvalidConfigurationException" => {
  289    244   
            crate::operation::create_custom_key_store::CreateCustomKeyStoreError::XksProxyVpcEndpointServiceInvalidConfigurationException({
  290    245   
                #[allow(unused_mut)]
  291    246   
                let mut tmp = {
  292    247   
                    #[allow(unused_mut)]
  293    248   
                    let mut output = crate::types::error::builders::XksProxyVpcEndpointServiceInvalidConfigurationExceptionBuilder::default();
  294    249   
                    output = crate::protocol_serde::shape_xks_proxy_vpc_endpoint_service_invalid_configuration_exception::de_xks_proxy_vpc_endpoint_service_invalid_configuration_exception_json_err(_response_body, output).map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
  295    250   
                    let output = output.meta(generic);
  296    251   
                    output.build()
  297    252   
                };
  298         -
                if tmp.message.is_none() {
  299         -
                    tmp.message = _error_message;
  300         -
                }
  301    253   
                tmp
  302    254   
            })
  303    255   
        }
  304    256   
        "XksProxyVpcEndpointServiceNotFoundException" => {
  305    257   
            crate::operation::create_custom_key_store::CreateCustomKeyStoreError::XksProxyVpcEndpointServiceNotFoundException({
  306    258   
                #[allow(unused_mut)]
  307    259   
                let mut tmp = {
  308    260   
                    #[allow(unused_mut)]
  309    261   
                    let mut output = crate::types::error::builders::XksProxyVpcEndpointServiceNotFoundExceptionBuilder::default();
  310    262   
                    output = crate::protocol_serde::shape_xks_proxy_vpc_endpoint_service_not_found_exception::de_xks_proxy_vpc_endpoint_service_not_found_exception_json_err(_response_body, output).map_err(crate::operation::create_custom_key_store::CreateCustomKeyStoreError::unhandled)?;
  311    263   
                    let output = output.meta(generic);
  312    264   
                    output.build()
  313    265   
                };
  314         -
                if tmp.message.is_none() {
  315         -
                    tmp.message = _error_message;
  316         -
                }
  317    266   
                tmp
  318    267   
            })
  319    268   
        }
  320    269   
        _ => crate::operation::create_custom_key_store::CreateCustomKeyStoreError::generic(generic),
  321    270   
    })
  322    271   
}
  323    272   
  324    273   
#[allow(clippy::unnecessary_wraps)]
  325    274   
pub fn de_create_custom_key_store_http_response(
  326    275   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/kms/src/protocol_serde/shape_create_grant.rs

@@ -1,1 +183,156 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::create_grant::CreateGrantError::DependencyTimeoutException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::DependencyTimeoutExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_dependency_timeout_exception::de_dependency_timeout_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::create_grant::CreateGrantError::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   
        "DisabledException" => crate::operation::create_grant::CreateGrantError::DisabledException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::DisabledExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_disabled_exception::de_disabled_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::create_grant::CreateGrantError::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   
        "DryRunOperationException" => crate::operation::create_grant::CreateGrantError::DryRunOperationException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::DryRunOperationExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_dry_run_operation_exception::de_dry_run_operation_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::create_grant::CreateGrantError::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   
        "InvalidArnException" => crate::operation::create_grant::CreateGrantError::InvalidArnException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::create_grant::CreateGrantError::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   
        "InvalidGrantTokenException" => crate::operation::create_grant::CreateGrantError::InvalidGrantTokenException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::InvalidGrantTokenExceptionBuilder::default();
   85     73   
                output =
   86     74   
                    crate::protocol_serde::shape_invalid_grant_token_exception::de_invalid_grant_token_exception_json_err(_response_body, output)
   87     75   
                        .map_err(crate::operation::create_grant::CreateGrantError::unhandled)?;
   88     76   
                let output = output.meta(generic);
   89     77   
                output.build()
   90     78   
            };
   91         -
            if tmp.message.is_none() {
   92         -
                tmp.message = _error_message;
   93         -
            }
   94     79   
            tmp
   95     80   
        }),
   96     81   
        "KMSInternalException" => crate::operation::create_grant::CreateGrantError::KmsInternalException({
   97     82   
            #[allow(unused_mut)]
   98     83   
            let mut tmp = {
   99     84   
                #[allow(unused_mut)]
  100     85   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
  101     86   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
  102     87   
                    .map_err(crate::operation::create_grant::CreateGrantError::unhandled)?;
  103     88   
                let output = output.meta(generic);
  104     89   
                output.build()
  105     90   
            };
  106         -
            if tmp.message.is_none() {
  107         -
                tmp.message = _error_message;
  108         -
            }
  109     91   
            tmp
  110     92   
        }),
  111     93   
        "KMSInvalidStateException" => crate::operation::create_grant::CreateGrantError::KmsInvalidStateException({
  112     94   
            #[allow(unused_mut)]
  113     95   
            let mut tmp = {
  114     96   
                #[allow(unused_mut)]
  115     97   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
  116     98   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
  117     99   
                    .map_err(crate::operation::create_grant::CreateGrantError::unhandled)?;
  118    100   
                let output = output.meta(generic);
  119    101   
                output.build()
  120    102   
            };
  121         -
            if tmp.message.is_none() {
  122         -
                tmp.message = _error_message;
  123         -
            }
  124    103   
            tmp
  125    104   
        }),
  126    105   
        "LimitExceededException" => crate::operation::create_grant::CreateGrantError::LimitExceededException({
  127    106   
            #[allow(unused_mut)]
  128    107   
            let mut tmp = {
  129    108   
                #[allow(unused_mut)]
  130    109   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
  131    110   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
  132    111   
                    .map_err(crate::operation::create_grant::CreateGrantError::unhandled)?;
  133    112   
                let output = output.meta(generic);
  134    113   
                output.build()
  135    114   
            };
  136         -
            if tmp.message.is_none() {
  137         -
                tmp.message = _error_message;
  138         -
            }
  139    115   
            tmp
  140    116   
        }),
  141    117   
        "NotFoundException" => crate::operation::create_grant::CreateGrantError::NotFoundException({
  142    118   
            #[allow(unused_mut)]
  143    119   
            let mut tmp = {
  144    120   
                #[allow(unused_mut)]
  145    121   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
  146    122   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
  147    123   
                    .map_err(crate::operation::create_grant::CreateGrantError::unhandled)?;
  148    124   
                let output = output.meta(generic);
  149    125   
                output.build()
  150    126   
            };
  151         -
            if tmp.message.is_none() {
  152         -
                tmp.message = _error_message;
  153         -
            }
  154    127   
            tmp
  155    128   
        }),
  156    129   
        _ => crate::operation::create_grant::CreateGrantError::generic(generic),
  157    130   
    })
  158    131   
}
  159    132   
  160    133   
#[allow(clippy::unnecessary_wraps)]
  161    134   
pub fn de_create_grant_http_response(
  162    135   
    _response_status: u16,
  163    136   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/kms/src/protocol_serde/shape_create_key.rs

@@ -1,1 +259,220 @@
   20     20   
        "CloudHsmClusterInvalidConfigurationException" => {
   21     21   
            crate::operation::create_key::CreateKeyError::CloudHsmClusterInvalidConfigurationException({
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut tmp = {
   24     24   
                    #[allow(unused_mut)]
   25     25   
                    let mut output = crate::types::error::builders::CloudHsmClusterInvalidConfigurationExceptionBuilder::default();
   26     26   
                    output = crate::protocol_serde::shape_cloud_hsm_cluster_invalid_configuration_exception::de_cloud_hsm_cluster_invalid_configuration_exception_json_err(_response_body, output).map_err(crate::operation::create_key::CreateKeyError::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   
        }
   36     33   
        "CustomKeyStoreInvalidStateException" => crate::operation::create_key::CreateKeyError::CustomKeyStoreInvalidStateException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::CustomKeyStoreInvalidStateExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_custom_key_store_invalid_state_exception::de_custom_key_store_invalid_state_exception_json_err(
   42     39   
                    _response_body,
   43     40   
                    output,
   44     41   
                )
   45     42   
                .map_err(crate::operation::create_key::CreateKeyError::unhandled)?;
   46     43   
                let output = output.meta(generic);
   47     44   
                output.build()
   48     45   
            };
   49         -
            if tmp.message.is_none() {
   50         -
                tmp.message = _error_message;
   51         -
            }
   52     46   
            tmp
   53     47   
        }),
   54     48   
        "CustomKeyStoreNotFoundException" => crate::operation::create_key::CreateKeyError::CustomKeyStoreNotFoundException({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::CustomKeyStoreNotFoundExceptionBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_custom_key_store_not_found_exception::de_custom_key_store_not_found_exception_json_err(
   60     54   
                    _response_body,
   61     55   
                    output,
   62     56   
                )
   63     57   
                .map_err(crate::operation::create_key::CreateKeyError::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   
        "DependencyTimeoutException" => crate::operation::create_key::CreateKeyError::DependencyTimeoutException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::DependencyTimeoutExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_dependency_timeout_exception::de_dependency_timeout_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::create_key::CreateKeyError::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   
        "InvalidArnException" => crate::operation::create_key::CreateKeyError::InvalidArnException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::create_key::CreateKeyError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        "KMSInternalException" => crate::operation::create_key::CreateKeyError::KmsInternalException({
  103     88   
            #[allow(unused_mut)]
  104     89   
            let mut tmp = {
  105     90   
                #[allow(unused_mut)]
  106     91   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
  107     92   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
  108     93   
                    .map_err(crate::operation::create_key::CreateKeyError::unhandled)?;
  109     94   
                let output = output.meta(generic);
  110     95   
                output.build()
  111     96   
            };
  112         -
            if tmp.message.is_none() {
  113         -
                tmp.message = _error_message;
  114         -
            }
  115     97   
            tmp
  116     98   
        }),
  117     99   
        "LimitExceededException" => crate::operation::create_key::CreateKeyError::LimitExceededException({
  118    100   
            #[allow(unused_mut)]
  119    101   
            let mut tmp = {
  120    102   
                #[allow(unused_mut)]
  121    103   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
  122    104   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
  123    105   
                    .map_err(crate::operation::create_key::CreateKeyError::unhandled)?;
  124    106   
                let output = output.meta(generic);
  125    107   
                output.build()
  126    108   
            };
  127         -
            if tmp.message.is_none() {
  128         -
                tmp.message = _error_message;
  129         -
            }
  130    109   
            tmp
  131    110   
        }),
  132    111   
        "MalformedPolicyDocumentException" => crate::operation::create_key::CreateKeyError::MalformedPolicyDocumentException({
  133    112   
            #[allow(unused_mut)]
  134    113   
            let mut tmp = {
  135    114   
                #[allow(unused_mut)]
  136    115   
                let mut output = crate::types::error::builders::MalformedPolicyDocumentExceptionBuilder::default();
  137    116   
                output = crate::protocol_serde::shape_malformed_policy_document_exception::de_malformed_policy_document_exception_json_err(
  138    117   
                    _response_body,
  139    118   
                    output,
  140    119   
                )
  141    120   
                .map_err(crate::operation::create_key::CreateKeyError::unhandled)?;
  142    121   
                let output = output.meta(generic);
  143    122   
                output.build()
  144    123   
            };
  145         -
            if tmp.message.is_none() {
  146         -
                tmp.message = _error_message;
  147         -
            }
  148    124   
            tmp
  149    125   
        }),
  150    126   
        "TagException" => crate::operation::create_key::CreateKeyError::TagException({
  151    127   
            #[allow(unused_mut)]
  152    128   
            let mut tmp = {
  153    129   
                #[allow(unused_mut)]
  154    130   
                let mut output = crate::types::error::builders::TagExceptionBuilder::default();
  155    131   
                output = crate::protocol_serde::shape_tag_exception::de_tag_exception_json_err(_response_body, output)
  156    132   
                    .map_err(crate::operation::create_key::CreateKeyError::unhandled)?;
  157    133   
                let output = output.meta(generic);
  158    134   
                output.build()
  159    135   
            };
  160         -
            if tmp.message.is_none() {
  161         -
                tmp.message = _error_message;
  162         -
            }
  163    136   
            tmp
  164    137   
        }),
  165    138   
        "UnsupportedOperationException" => crate::operation::create_key::CreateKeyError::UnsupportedOperationException({
  166    139   
            #[allow(unused_mut)]
  167    140   
            let mut tmp = {
  168    141   
                #[allow(unused_mut)]
  169    142   
                let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  170    143   
                output =
  171    144   
                    crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(_response_body, output)
  172    145   
                        .map_err(crate::operation::create_key::CreateKeyError::unhandled)?;
  173    146   
                let output = output.meta(generic);
  174    147   
                output.build()
  175    148   
            };
  176         -
            if tmp.message.is_none() {
  177         -
                tmp.message = _error_message;
  178         -
            }
  179    149   
            tmp
  180    150   
        }),
  181    151   
        "XksKeyAlreadyInUseException" => crate::operation::create_key::CreateKeyError::XksKeyAlreadyInUseException({
  182    152   
            #[allow(unused_mut)]
  183    153   
            let mut tmp = {
  184    154   
                #[allow(unused_mut)]
  185    155   
                let mut output = crate::types::error::builders::XksKeyAlreadyInUseExceptionBuilder::default();
  186    156   
                output = crate::protocol_serde::shape_xks_key_already_in_use_exception::de_xks_key_already_in_use_exception_json_err(
  187    157   
                    _response_body,
  188    158   
                    output,
  189    159   
                )
  190    160   
                .map_err(crate::operation::create_key::CreateKeyError::unhandled)?;
  191    161   
                let output = output.meta(generic);
  192    162   
                output.build()
  193    163   
            };
  194         -
            if tmp.message.is_none() {
  195         -
                tmp.message = _error_message;
  196         -
            }
  197    164   
            tmp
  198    165   
        }),
  199    166   
        "XksKeyInvalidConfigurationException" => crate::operation::create_key::CreateKeyError::XksKeyInvalidConfigurationException({
  200    167   
            #[allow(unused_mut)]
  201    168   
            let mut tmp = {
  202    169   
                #[allow(unused_mut)]
  203    170   
                let mut output = crate::types::error::builders::XksKeyInvalidConfigurationExceptionBuilder::default();
  204    171   
                output = crate::protocol_serde::shape_xks_key_invalid_configuration_exception::de_xks_key_invalid_configuration_exception_json_err(
  205    172   
                    _response_body,
  206    173   
                    output,
  207    174   
                )
  208    175   
                .map_err(crate::operation::create_key::CreateKeyError::unhandled)?;
  209    176   
                let output = output.meta(generic);
  210    177   
                output.build()
  211    178   
            };
  212         -
            if tmp.message.is_none() {
  213         -
                tmp.message = _error_message;
  214         -
            }
  215    179   
            tmp
  216    180   
        }),
  217    181   
        "XksKeyNotFoundException" => crate::operation::create_key::CreateKeyError::XksKeyNotFoundException({
  218    182   
            #[allow(unused_mut)]
  219    183   
            let mut tmp = {
  220    184   
                #[allow(unused_mut)]
  221    185   
                let mut output = crate::types::error::builders::XksKeyNotFoundExceptionBuilder::default();
  222    186   
                output = crate::protocol_serde::shape_xks_key_not_found_exception::de_xks_key_not_found_exception_json_err(_response_body, output)
  223    187   
                    .map_err(crate::operation::create_key::CreateKeyError::unhandled)?;
  224    188   
                let output = output.meta(generic);
  225    189   
                output.build()
  226    190   
            };
  227         -
            if tmp.message.is_none() {
  228         -
                tmp.message = _error_message;
  229         -
            }
  230    191   
            tmp
  231    192   
        }),
  232    193   
        _ => crate::operation::create_key::CreateKeyError::generic(generic),
  233    194   
    })
  234    195   
}
  235    196   
  236    197   
#[allow(clippy::unnecessary_wraps)]
  237    198   
pub fn de_create_key_http_response(
  238    199   
    _response_status: u16,
  239    200   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/kms/src/protocol_serde/shape_decrypt.rs

@@ -1,1 +213,180 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::decrypt::DecryptError::DependencyTimeoutException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::DependencyTimeoutExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_dependency_timeout_exception::de_dependency_timeout_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::decrypt::DecryptError::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   
        "DisabledException" => crate::operation::decrypt::DecryptError::DisabledException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::DisabledExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_disabled_exception::de_disabled_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::decrypt::DecryptError::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   
        "DryRunOperationException" => crate::operation::decrypt::DecryptError::DryRunOperationException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::DryRunOperationExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_dry_run_operation_exception::de_dry_run_operation_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::decrypt::DecryptError::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   
        "IncorrectKeyException" => crate::operation::decrypt::DecryptError::IncorrectKeyException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::IncorrectKeyExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_incorrect_key_exception::de_incorrect_key_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::decrypt::DecryptError::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   
        "InvalidCiphertextException" => crate::operation::decrypt::DecryptError::InvalidCiphertextException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::InvalidCiphertextExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_invalid_ciphertext_exception::de_invalid_ciphertext_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::decrypt::DecryptError::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   
        "InvalidGrantTokenException" => crate::operation::decrypt::DecryptError::InvalidGrantTokenException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::InvalidGrantTokenExceptionBuilder::default();
  100     85   
                output =
  101     86   
                    crate::protocol_serde::shape_invalid_grant_token_exception::de_invalid_grant_token_exception_json_err(_response_body, output)
  102     87   
                        .map_err(crate::operation::decrypt::DecryptError::unhandled)?;
  103     88   
                let output = output.meta(generic);
  104     89   
                output.build()
  105     90   
            };
  106         -
            if tmp.message.is_none() {
  107         -
                tmp.message = _error_message;
  108         -
            }
  109     91   
            tmp
  110     92   
        }),
  111     93   
        "InvalidKeyUsageException" => crate::operation::decrypt::DecryptError::InvalidKeyUsageException({
  112     94   
            #[allow(unused_mut)]
  113     95   
            let mut tmp = {
  114     96   
                #[allow(unused_mut)]
  115     97   
                let mut output = crate::types::error::builders::InvalidKeyUsageExceptionBuilder::default();
  116     98   
                output = crate::protocol_serde::shape_invalid_key_usage_exception::de_invalid_key_usage_exception_json_err(_response_body, output)
  117     99   
                    .map_err(crate::operation::decrypt::DecryptError::unhandled)?;
  118    100   
                let output = output.meta(generic);
  119    101   
                output.build()
  120    102   
            };
  121         -
            if tmp.message.is_none() {
  122         -
                tmp.message = _error_message;
  123         -
            }
  124    103   
            tmp
  125    104   
        }),
  126    105   
        "KeyUnavailableException" => crate::operation::decrypt::DecryptError::KeyUnavailableException({
  127    106   
            #[allow(unused_mut)]
  128    107   
            let mut tmp = {
  129    108   
                #[allow(unused_mut)]
  130    109   
                let mut output = crate::types::error::builders::KeyUnavailableExceptionBuilder::default();
  131    110   
                output = crate::protocol_serde::shape_key_unavailable_exception::de_key_unavailable_exception_json_err(_response_body, output)
  132    111   
                    .map_err(crate::operation::decrypt::DecryptError::unhandled)?;
  133    112   
                let output = output.meta(generic);
  134    113   
                output.build()
  135    114   
            };
  136         -
            if tmp.message.is_none() {
  137         -
                tmp.message = _error_message;
  138         -
            }
  139    115   
            tmp
  140    116   
        }),
  141    117   
        "KMSInternalException" => crate::operation::decrypt::DecryptError::KmsInternalException({
  142    118   
            #[allow(unused_mut)]
  143    119   
            let mut tmp = {
  144    120   
                #[allow(unused_mut)]
  145    121   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
  146    122   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
  147    123   
                    .map_err(crate::operation::decrypt::DecryptError::unhandled)?;
  148    124   
                let output = output.meta(generic);
  149    125   
                output.build()
  150    126   
            };
  151         -
            if tmp.message.is_none() {
  152         -
                tmp.message = _error_message;
  153         -
            }
  154    127   
            tmp
  155    128   
        }),
  156    129   
        "KMSInvalidStateException" => crate::operation::decrypt::DecryptError::KmsInvalidStateException({
  157    130   
            #[allow(unused_mut)]
  158    131   
            let mut tmp = {
  159    132   
                #[allow(unused_mut)]
  160    133   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
  161    134   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
  162    135   
                    .map_err(crate::operation::decrypt::DecryptError::unhandled)?;
  163    136   
                let output = output.meta(generic);
  164    137   
                output.build()
  165    138   
            };
  166         -
            if tmp.message.is_none() {
  167         -
                tmp.message = _error_message;
  168         -
            }
  169    139   
            tmp
  170    140   
        }),
  171    141   
        "NotFoundException" => crate::operation::decrypt::DecryptError::NotFoundException({
  172    142   
            #[allow(unused_mut)]
  173    143   
            let mut tmp = {
  174    144   
                #[allow(unused_mut)]
  175    145   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
  176    146   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
  177    147   
                    .map_err(crate::operation::decrypt::DecryptError::unhandled)?;
  178    148   
                let output = output.meta(generic);
  179    149   
                output.build()
  180    150   
            };
  181         -
            if tmp.message.is_none() {
  182         -
                tmp.message = _error_message;
  183         -
            }
  184    151   
            tmp
  185    152   
        }),
  186    153   
        _ => crate::operation::decrypt::DecryptError::generic(generic),
  187    154   
    })
  188    155   
}
  189    156   
  190    157   
#[allow(clippy::unnecessary_wraps)]
  191    158   
pub fn de_decrypt_http_response(
  192    159   
    _response_status: u16,
  193    160   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,