AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05 (ignoring whitespace)

Files changed:

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

@@ -3,3 +129,114 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::CustomKeyStoreInvalidStateExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_custom_key_store_invalid_state_exception::de_custom_key_store_invalid_state_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::generate_random::GenerateRandomError::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   
        "CustomKeyStoreNotFoundException" => crate::operation::generate_random::GenerateRandomError::CustomKeyStoreNotFoundException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::CustomKeyStoreNotFoundExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_custom_key_store_not_found_exception::de_custom_key_store_not_found_exception_json_err(
   44     41   
                    _response_body,
   45     42   
                    output,
   46     43   
                )
   47     44   
                .map_err(crate::operation::generate_random::GenerateRandomError::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   
        "DependencyTimeoutException" => crate::operation::generate_random::GenerateRandomError::DependencyTimeoutException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::DependencyTimeoutExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_dependency_timeout_exception::de_dependency_timeout_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::generate_random::GenerateRandomError::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   
        "KMSInternalException" => crate::operation::generate_random::GenerateRandomError::KmsInternalException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::generate_random::GenerateRandomError::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   
        "UnsupportedOperationException" => crate::operation::generate_random::GenerateRandomError::UnsupportedOperationException({
   87     75   
            #[allow(unused_mut)]
   88     76   
            let mut tmp = {
   89     77   
                #[allow(unused_mut)]
   90     78   
                let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
   91     79   
                output =
   92     80   
                    crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(_response_body, output)
   93     81   
                        .map_err(crate::operation::generate_random::GenerateRandomError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        _ => crate::operation::generate_random::GenerateRandomError::generic(generic),
  103     88   
    })
  104     89   
}
  105     90   
  106     91   
#[allow(clippy::unnecessary_wraps)]
  107     92   
pub fn de_generate_random_http_response(
  108     93   
    _response_status: u16,
  109     94   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

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

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

@@ -3,3 +141,123 @@
   23     23   
        "DependencyTimeoutException" => crate::operation::get_key_rotation_status::GetKeyRotationStatusError::DependencyTimeoutException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::DependencyTimeoutExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_dependency_timeout_exception::de_dependency_timeout_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::get_key_rotation_status::GetKeyRotationStatusError::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   
        "InvalidArnException" => crate::operation::get_key_rotation_status::GetKeyRotationStatusError::InvalidArnException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::get_key_rotation_status::GetKeyRotationStatusError::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   
        "KMSInternalException" => crate::operation::get_key_rotation_status::GetKeyRotationStatusError::KmsInternalException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::get_key_rotation_status::GetKeyRotationStatusError::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   
        "KMSInvalidStateException" => crate::operation::get_key_rotation_status::GetKeyRotationStatusError::KmsInvalidStateException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::get_key_rotation_status::GetKeyRotationStatusError::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   
        "NotFoundException" => crate::operation::get_key_rotation_status::GetKeyRotationStatusError::NotFoundException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::get_key_rotation_status::GetKeyRotationStatusError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        "UnsupportedOperationException" => crate::operation::get_key_rotation_status::GetKeyRotationStatusError::UnsupportedOperationException({
   99     84   
            #[allow(unused_mut)]
  100     85   
            let mut tmp = {
  101     86   
                #[allow(unused_mut)]
  102     87   
                let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  103     88   
                output =
  104     89   
                    crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(_response_body, output)
  105     90   
                        .map_err(crate::operation::get_key_rotation_status::GetKeyRotationStatusError::unhandled)?;
  106     91   
                let output = output.meta(generic);
  107     92   
                output.build()
  108     93   
            };
  109         -
            if tmp.message.is_none() {
  110         -
                tmp.message = _error_message;
  111         -
            }
  112     94   
            tmp
  113     95   
        }),
  114     96   
        _ => crate::operation::get_key_rotation_status::GetKeyRotationStatusError::generic(generic),
  115     97   
    })
  116     98   
}
  117     99   
  118    100   
#[allow(clippy::unnecessary_wraps)]
  119    101   
pub fn de_get_key_rotation_status_http_response(
  120    102   
    _response_status: u16,
  121    103   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +145,127 @@
   27     27   
        "DependencyTimeoutException" => crate::operation::get_parameters_for_import::GetParametersForImportError::DependencyTimeoutException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::DependencyTimeoutExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_dependency_timeout_exception::de_dependency_timeout_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::get_parameters_for_import::GetParametersForImportError::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   
        "InvalidArnException" => crate::operation::get_parameters_for_import::GetParametersForImportError::InvalidArnException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::get_parameters_for_import::GetParametersForImportError::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   
        "KMSInternalException" => crate::operation::get_parameters_for_import::GetParametersForImportError::KmsInternalException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::get_parameters_for_import::GetParametersForImportError::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   
        "KMSInvalidStateException" => crate::operation::get_parameters_for_import::GetParametersForImportError::KmsInvalidStateException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::get_parameters_for_import::GetParametersForImportError::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   
        "NotFoundException" => crate::operation::get_parameters_for_import::GetParametersForImportError::NotFoundException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::get_parameters_for_import::GetParametersForImportError::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   
        "UnsupportedOperationException" => crate::operation::get_parameters_for_import::GetParametersForImportError::UnsupportedOperationException({
  103     88   
            #[allow(unused_mut)]
  104     89   
            let mut tmp = {
  105     90   
                #[allow(unused_mut)]
  106     91   
                let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  107     92   
                output =
  108     93   
                    crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(_response_body, output)
  109     94   
                        .map_err(crate::operation::get_parameters_for_import::GetParametersForImportError::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::get_parameters_for_import::GetParametersForImportError::generic(generic),
  119    101   
    })
  120    102   
}
  121    103   
  122    104   
#[allow(clippy::unnecessary_wraps)]
  123    105   
pub fn de_get_parameters_for_import_http_response(
  124    106   
    _response_status: u16,
  125    107   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +199,169 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::get_public_key::GetPublicKeyError::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::get_public_key::GetPublicKeyError::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::get_public_key::GetPublicKeyError::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::get_public_key::GetPublicKeyError::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   
        "InvalidArnException" => crate::operation::get_public_key::GetPublicKeyError::InvalidArnException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::get_public_key::GetPublicKeyError::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   
        "InvalidGrantTokenException" => crate::operation::get_public_key::GetPublicKeyError::InvalidGrantTokenException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::InvalidGrantTokenExceptionBuilder::default();
   70     61   
                output =
   71     62   
                    crate::protocol_serde::shape_invalid_grant_token_exception::de_invalid_grant_token_exception_json_err(_response_body, output)
   72     63   
                        .map_err(crate::operation::get_public_key::GetPublicKeyError::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   
        "InvalidKeyUsageException" => crate::operation::get_public_key::GetPublicKeyError::InvalidKeyUsageException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::InvalidKeyUsageExceptionBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_invalid_key_usage_exception::de_invalid_key_usage_exception_json_err(_response_body, output)
   87     75   
                    .map_err(crate::operation::get_public_key::GetPublicKeyError::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   
        "KeyUnavailableException" => crate::operation::get_public_key::GetPublicKeyError::KeyUnavailableException({
   97     82   
            #[allow(unused_mut)]
   98     83   
            let mut tmp = {
   99     84   
                #[allow(unused_mut)]
  100     85   
                let mut output = crate::types::error::builders::KeyUnavailableExceptionBuilder::default();
  101     86   
                output = crate::protocol_serde::shape_key_unavailable_exception::de_key_unavailable_exception_json_err(_response_body, output)
  102     87   
                    .map_err(crate::operation::get_public_key::GetPublicKeyError::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   
        "KMSInternalException" => crate::operation::get_public_key::GetPublicKeyError::KmsInternalException({
  112     94   
            #[allow(unused_mut)]
  113     95   
            let mut tmp = {
  114     96   
                #[allow(unused_mut)]
  115     97   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
  116     98   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
  117     99   
                    .map_err(crate::operation::get_public_key::GetPublicKeyError::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   
        "KMSInvalidStateException" => crate::operation::get_public_key::GetPublicKeyError::KmsInvalidStateException({
  127    106   
            #[allow(unused_mut)]
  128    107   
            let mut tmp = {
  129    108   
                #[allow(unused_mut)]
  130    109   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
  131    110   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
  132    111   
                    .map_err(crate::operation::get_public_key::GetPublicKeyError::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::get_public_key::GetPublicKeyError::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::get_public_key::GetPublicKeyError::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   
        "UnsupportedOperationException" => crate::operation::get_public_key::GetPublicKeyError::UnsupportedOperationException({
  157    130   
            #[allow(unused_mut)]
  158    131   
            let mut tmp = {
  159    132   
                #[allow(unused_mut)]
  160    133   
                let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  161    134   
                output =
  162    135   
                    crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(_response_body, output)
  163    136   
                        .map_err(crate::operation::get_public_key::GetPublicKeyError::unhandled)?;
  164    137   
                let output = output.meta(generic);
  165    138   
                output.build()
  166    139   
            };
  167         -
            if tmp.message.is_none() {
  168         -
                tmp.message = _error_message;
  169         -
            }
  170    140   
            tmp
  171    141   
        }),
  172    142   
        _ => crate::operation::get_public_key::GetPublicKeyError::generic(generic),
  173    143   
    })
  174    144   
}
  175    145   
  176    146   
#[allow(clippy::unnecessary_wraps)]
  177    147   
pub fn de_get_public_key_http_response(
  178    148   
    _response_status: u16,
  179    149   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +204,174 @@
   21     21   
        "DependencyTimeoutException" => crate::operation::import_key_material::ImportKeyMaterialError::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::import_key_material::ImportKeyMaterialError::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   
        "ExpiredImportTokenException" => crate::operation::import_key_material::ImportKeyMaterialError::ExpiredImportTokenException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::ExpiredImportTokenExceptionBuilder::default();
   41     38   
                output =
   42     39   
                    crate::protocol_serde::shape_expired_import_token_exception::de_expired_import_token_exception_json_err(_response_body, output)
   43     40   
                        .map_err(crate::operation::import_key_material::ImportKeyMaterialError::unhandled)?;
   44     41   
                let output = output.meta(generic);
   45     42   
                output.build()
   46     43   
            };
   47         -
            if tmp.message.is_none() {
   48         -
                tmp.message = _error_message;
   49         -
            }
   50     44   
            tmp
   51     45   
        }),
   52     46   
        "IncorrectKeyMaterialException" => crate::operation::import_key_material::ImportKeyMaterialError::IncorrectKeyMaterialException({
   53     47   
            #[allow(unused_mut)]
   54     48   
            let mut tmp = {
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut output = crate::types::error::builders::IncorrectKeyMaterialExceptionBuilder::default();
   57     51   
                output = crate::protocol_serde::shape_incorrect_key_material_exception::de_incorrect_key_material_exception_json_err(
   58     52   
                    _response_body,
   59     53   
                    output,
   60     54   
                )
   61     55   
                .map_err(crate::operation::import_key_material::ImportKeyMaterialError::unhandled)?;
   62     56   
                let output = output.meta(generic);
   63     57   
                output.build()
   64     58   
            };
   65         -
            if tmp.message.is_none() {
   66         -
                tmp.message = _error_message;
   67         -
            }
   68     59   
            tmp
   69     60   
        }),
   70     61   
        "InvalidArnException" => crate::operation::import_key_material::ImportKeyMaterialError::InvalidArnException({
   71     62   
            #[allow(unused_mut)]
   72     63   
            let mut tmp = {
   73     64   
                #[allow(unused_mut)]
   74     65   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   75     66   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   76     67   
                    .map_err(crate::operation::import_key_material::ImportKeyMaterialError::unhandled)?;
   77     68   
                let output = output.meta(generic);
   78     69   
                output.build()
   79     70   
            };
   80         -
            if tmp.message.is_none() {
   81         -
                tmp.message = _error_message;
   82         -
            }
   83     71   
            tmp
   84     72   
        }),
   85     73   
        "InvalidCiphertextException" => crate::operation::import_key_material::ImportKeyMaterialError::InvalidCiphertextException({
   86     74   
            #[allow(unused_mut)]
   87     75   
            let mut tmp = {
   88     76   
                #[allow(unused_mut)]
   89     77   
                let mut output = crate::types::error::builders::InvalidCiphertextExceptionBuilder::default();
   90     78   
                output = crate::protocol_serde::shape_invalid_ciphertext_exception::de_invalid_ciphertext_exception_json_err(_response_body, output)
   91     79   
                    .map_err(crate::operation::import_key_material::ImportKeyMaterialError::unhandled)?;
   92     80   
                let output = output.meta(generic);
   93     81   
                output.build()
   94     82   
            };
   95         -
            if tmp.message.is_none() {
   96         -
                tmp.message = _error_message;
   97         -
            }
   98     83   
            tmp
   99     84   
        }),
  100     85   
        "InvalidImportTokenException" => crate::operation::import_key_material::ImportKeyMaterialError::InvalidImportTokenException({
  101     86   
            #[allow(unused_mut)]
  102     87   
            let mut tmp = {
  103     88   
                #[allow(unused_mut)]
  104     89   
                let mut output = crate::types::error::builders::InvalidImportTokenExceptionBuilder::default();
  105     90   
                output =
  106     91   
                    crate::protocol_serde::shape_invalid_import_token_exception::de_invalid_import_token_exception_json_err(_response_body, output)
  107     92   
                        .map_err(crate::operation::import_key_material::ImportKeyMaterialError::unhandled)?;
  108     93   
                let output = output.meta(generic);
  109     94   
                output.build()
  110     95   
            };
  111         -
            if tmp.message.is_none() {
  112         -
                tmp.message = _error_message;
  113         -
            }
  114     96   
            tmp
  115     97   
        }),
  116     98   
        "KMSInternalException" => crate::operation::import_key_material::ImportKeyMaterialError::KmsInternalException({
  117     99   
            #[allow(unused_mut)]
  118    100   
            let mut tmp = {
  119    101   
                #[allow(unused_mut)]
  120    102   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
  121    103   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
  122    104   
                    .map_err(crate::operation::import_key_material::ImportKeyMaterialError::unhandled)?;
  123    105   
                let output = output.meta(generic);
  124    106   
                output.build()
  125    107   
            };
  126         -
            if tmp.message.is_none() {
  127         -
                tmp.message = _error_message;
  128         -
            }
  129    108   
            tmp
  130    109   
        }),
  131    110   
        "KMSInvalidStateException" => crate::operation::import_key_material::ImportKeyMaterialError::KmsInvalidStateException({
  132    111   
            #[allow(unused_mut)]
  133    112   
            let mut tmp = {
  134    113   
                #[allow(unused_mut)]
  135    114   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
  136    115   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
  137    116   
                    .map_err(crate::operation::import_key_material::ImportKeyMaterialError::unhandled)?;
  138    117   
                let output = output.meta(generic);
  139    118   
                output.build()
  140    119   
            };
  141         -
            if tmp.message.is_none() {
  142         -
                tmp.message = _error_message;
  143         -
            }
  144    120   
            tmp
  145    121   
        }),
  146    122   
        "NotFoundException" => crate::operation::import_key_material::ImportKeyMaterialError::NotFoundException({
  147    123   
            #[allow(unused_mut)]
  148    124   
            let mut tmp = {
  149    125   
                #[allow(unused_mut)]
  150    126   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
  151    127   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
  152    128   
                    .map_err(crate::operation::import_key_material::ImportKeyMaterialError::unhandled)?;
  153    129   
                let output = output.meta(generic);
  154    130   
                output.build()
  155    131   
            };
  156         -
            if tmp.message.is_none() {
  157         -
                tmp.message = _error_message;
  158         -
            }
  159    132   
            tmp
  160    133   
        }),
  161    134   
        "UnsupportedOperationException" => crate::operation::import_key_material::ImportKeyMaterialError::UnsupportedOperationException({
  162    135   
            #[allow(unused_mut)]
  163    136   
            let mut tmp = {
  164    137   
                #[allow(unused_mut)]
  165    138   
                let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  166    139   
                output =
  167    140   
                    crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(_response_body, output)
  168    141   
                        .map_err(crate::operation::import_key_material::ImportKeyMaterialError::unhandled)?;
  169    142   
                let output = output.meta(generic);
  170    143   
                output.build()
  171    144   
            };
  172         -
            if tmp.message.is_none() {
  173         -
                tmp.message = _error_message;
  174         -
            }
  175    145   
            tmp
  176    146   
        }),
  177    147   
        _ => crate::operation::import_key_material::ImportKeyMaterialError::generic(generic),
  178    148   
    })
  179    149   
}
  180    150   
  181    151   
#[allow(clippy::unnecessary_wraps)]
  182    152   
pub fn de_import_key_material_http_response(
  183    153   
    _response_status: u16,
  184    154   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +122,107 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::list_aliases::ListAliasesError::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::list_aliases::ListAliasesError::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   
        "InvalidArnException" => crate::operation::list_aliases::ListAliasesError::InvalidArnException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::list_aliases::ListAliasesError::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   
        "InvalidMarkerException" => crate::operation::list_aliases::ListAliasesError::InvalidMarkerException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidMarkerExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_marker_exception::de_invalid_marker_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::list_aliases::ListAliasesError::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::list_aliases::ListAliasesError::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::list_aliases::ListAliasesError::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   
        "NotFoundException" => crate::operation::list_aliases::ListAliasesError::NotFoundException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::list_aliases::ListAliasesError::unhandled)?;
   87     75   
                let output = output.meta(generic);
   88     76   
                output.build()
   89     77   
            };
   90         -
            if tmp.message.is_none() {
   91         -
                tmp.message = _error_message;
   92         -
            }
   93     78   
            tmp
   94     79   
        }),
   95     80   
        _ => crate::operation::list_aliases::ListAliasesError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_list_aliases_http_response(
  101     86   
    _response_status: u16,
  102     87   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +152,131 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::list_grants::ListGrantsError::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::list_grants::ListGrantsError::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   
        "InvalidArnException" => crate::operation::list_grants::ListGrantsError::InvalidArnException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::list_grants::ListGrantsError::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   
        "InvalidGrantIdException" => crate::operation::list_grants::ListGrantsError::InvalidGrantIdException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidGrantIdExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_grant_id_exception::de_invalid_grant_id_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::list_grants::ListGrantsError::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   
        "InvalidMarkerException" => crate::operation::list_grants::ListGrantsError::InvalidMarkerException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::InvalidMarkerExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_invalid_marker_exception::de_invalid_marker_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::list_grants::ListGrantsError::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   
        "KMSInternalException" => crate::operation::list_grants::ListGrantsError::KmsInternalException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::list_grants::ListGrantsError::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   
        "KMSInvalidStateException" => crate::operation::list_grants::ListGrantsError::KmsInvalidStateException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
  100     85   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
  101     86   
                    .map_err(crate::operation::list_grants::ListGrantsError::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::list_grants::ListGrantsError::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::list_grants::ListGrantsError::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::list_grants::ListGrantsError::generic(generic),
  126    105   
    })
  127    106   
}
  128    107   
  129    108   
#[allow(clippy::unnecessary_wraps)]
  130    109   
pub fn de_list_grants_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_list_key_policies.rs

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

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

@@ -1,1 +138,120 @@
   20     20   
        "InvalidArnException" => crate::operation::list_key_rotations::ListKeyRotationsError::InvalidArnException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::list_key_rotations::ListKeyRotationsError::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   
        "InvalidMarkerException" => crate::operation::list_key_rotations::ListKeyRotationsError::InvalidMarkerException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidMarkerExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_marker_exception::de_invalid_marker_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::list_key_rotations::ListKeyRotationsError::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   
        "KMSInternalException" => crate::operation::list_key_rotations::ListKeyRotationsError::KmsInternalException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::list_key_rotations::ListKeyRotationsError::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   
        "KMSInvalidStateException" => crate::operation::list_key_rotations::ListKeyRotationsError::KmsInvalidStateException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::list_key_rotations::ListKeyRotationsError::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   
        "NotFoundException" => crate::operation::list_key_rotations::ListKeyRotationsError::NotFoundException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::list_key_rotations::ListKeyRotationsError::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   
        "UnsupportedOperationException" => crate::operation::list_key_rotations::ListKeyRotationsError::UnsupportedOperationException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  100     85   
                output =
  101     86   
                    crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(_response_body, output)
  102     87   
                        .map_err(crate::operation::list_key_rotations::ListKeyRotationsError::unhandled)?;
  103     88   
                let output = output.meta(generic);
  104     89   
                output.build()
  105     90   
            };
  106         -
            if tmp.message.is_none() {
  107         -
                tmp.message = _error_message;
  108         -
            }
  109     91   
            tmp
  110     92   
        }),
  111     93   
        _ => crate::operation::list_key_rotations::ListKeyRotationsError::generic(generic),
  112     94   
    })
  113     95   
}
  114     96   
  115     97   
#[allow(clippy::unnecessary_wraps)]
  116     98   
pub fn de_list_key_rotations_http_response(
  117     99   
    _response_status: u16,
  118    100   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +92,83 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::list_keys::ListKeysError::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::list_keys::ListKeysError::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   
        "InvalidMarkerException" => crate::operation::list_keys::ListKeysError::InvalidMarkerException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidMarkerExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_marker_exception::de_invalid_marker_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::list_keys::ListKeysError::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   
        "KMSInternalException" => crate::operation::list_keys::ListKeysError::KmsInternalException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::list_keys::ListKeysError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        _ => crate::operation::list_keys::ListKeysError::generic(generic),
   66     57   
    })
   67     58   
}
   68     59   
   69     60   
#[allow(clippy::unnecessary_wraps)]
   70     61   
pub fn de_list_keys_http_response(
   71     62   
    _response_status: u16,
   72     63   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +107,95 @@
   20     20   
        "InvalidArnException" => crate::operation::list_resource_tags::ListResourceTagsError::InvalidArnException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::list_resource_tags::ListResourceTagsError::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   
        "InvalidMarkerException" => crate::operation::list_resource_tags::ListResourceTagsError::InvalidMarkerException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidMarkerExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_marker_exception::de_invalid_marker_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::list_resource_tags::ListResourceTagsError::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   
        "KMSInternalException" => crate::operation::list_resource_tags::ListResourceTagsError::KmsInternalException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::list_resource_tags::ListResourceTagsError::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   
        "NotFoundException" => crate::operation::list_resource_tags::ListResourceTagsError::NotFoundException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::list_resource_tags::ListResourceTagsError::unhandled)?;
   72     63   
                let output = output.meta(generic);
   73     64   
                output.build()
   74     65   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     66   
            tmp
   79     67   
        }),
   80     68   
        _ => crate::operation::list_resource_tags::ListResourceTagsError::generic(generic),
   81     69   
    })
   82     70   
}
   83     71   
   84     72   
#[allow(clippy::unnecessary_wraps)]
   85     73   
pub fn de_list_resource_tags_http_response(
   86     74   
    _response_status: u16,
   87     75   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +125,110 @@
   23     23   
        "DependencyTimeoutException" => crate::operation::list_retirable_grants::ListRetirableGrantsError::DependencyTimeoutException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::DependencyTimeoutExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_dependency_timeout_exception::de_dependency_timeout_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::list_retirable_grants::ListRetirableGrantsError::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   
        "InvalidArnException" => crate::operation::list_retirable_grants::ListRetirableGrantsError::InvalidArnException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::list_retirable_grants::ListRetirableGrantsError::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   
        "InvalidMarkerException" => crate::operation::list_retirable_grants::ListRetirableGrantsError::InvalidMarkerException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidMarkerExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_marker_exception::de_invalid_marker_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::list_retirable_grants::ListRetirableGrantsError::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   
        "KMSInternalException" => crate::operation::list_retirable_grants::ListRetirableGrantsError::KmsInternalException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::list_retirable_grants::ListRetirableGrantsError::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   
        "NotFoundException" => crate::operation::list_retirable_grants::ListRetirableGrantsError::NotFoundException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::list_retirable_grants::ListRetirableGrantsError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        _ => crate::operation::list_retirable_grants::ListRetirableGrantsError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_list_retirable_grants_http_response(
  104     89   
    _response_status: u16,
  105     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +170,146 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::put_key_policy::PutKeyPolicyError::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::put_key_policy::PutKeyPolicyError::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   
        "InvalidArnException" => crate::operation::put_key_policy::PutKeyPolicyError::InvalidArnException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::put_key_policy::PutKeyPolicyError::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   
        "KMSInternalException" => crate::operation::put_key_policy::PutKeyPolicyError::KmsInternalException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::put_key_policy::PutKeyPolicyError::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   
        "KMSInvalidStateException" => crate::operation::put_key_policy::PutKeyPolicyError::KmsInvalidStateException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::put_key_policy::PutKeyPolicyError::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   
        "LimitExceededException" => crate::operation::put_key_policy::PutKeyPolicyError::LimitExceededException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::put_key_policy::PutKeyPolicyError::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   
        "MalformedPolicyDocumentException" => crate::operation::put_key_policy::PutKeyPolicyError::MalformedPolicyDocumentException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::MalformedPolicyDocumentExceptionBuilder::default();
  100     85   
                output = crate::protocol_serde::shape_malformed_policy_document_exception::de_malformed_policy_document_exception_json_err(
  101     86   
                    _response_body,
  102     87   
                    output,
  103     88   
                )
  104     89   
                .map_err(crate::operation::put_key_policy::PutKeyPolicyError::unhandled)?;
  105     90   
                let output = output.meta(generic);
  106     91   
                output.build()
  107     92   
            };
  108         -
            if tmp.message.is_none() {
  109         -
                tmp.message = _error_message;
  110         -
            }
  111     93   
            tmp
  112     94   
        }),
  113     95   
        "NotFoundException" => crate::operation::put_key_policy::PutKeyPolicyError::NotFoundException({
  114     96   
            #[allow(unused_mut)]
  115     97   
            let mut tmp = {
  116     98   
                #[allow(unused_mut)]
  117     99   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
  118    100   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
  119    101   
                    .map_err(crate::operation::put_key_policy::PutKeyPolicyError::unhandled)?;
  120    102   
                let output = output.meta(generic);
  121    103   
                output.build()
  122    104   
            };
  123         -
            if tmp.message.is_none() {
  124         -
                tmp.message = _error_message;
  125         -
            }
  126    105   
            tmp
  127    106   
        }),
  128    107   
        "UnsupportedOperationException" => crate::operation::put_key_policy::PutKeyPolicyError::UnsupportedOperationException({
  129    108   
            #[allow(unused_mut)]
  130    109   
            let mut tmp = {
  131    110   
                #[allow(unused_mut)]
  132    111   
                let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  133    112   
                output =
  134    113   
                    crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(_response_body, output)
  135    114   
                        .map_err(crate::operation::put_key_policy::PutKeyPolicyError::unhandled)?;
  136    115   
                let output = output.meta(generic);
  137    116   
                output.build()
  138    117   
            };
  139         -
            if tmp.message.is_none() {
  140         -
                tmp.message = _error_message;
  141         -
            }
  142    118   
            tmp
  143    119   
        }),
  144    120   
        _ => crate::operation::put_key_policy::PutKeyPolicyError::generic(generic),
  145    121   
    })
  146    122   
}
  147    123   
  148    124   
#[allow(clippy::unnecessary_wraps)]
  149    125   
pub fn de_put_key_policy_http_response(
  150    126   
    _response_status: u16,
  151    127   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +213,180 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::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::re_encrypt::ReEncryptError::generic(generic),
  187    154   
    })
  188    155   
}
  189    156   
  190    157   
#[allow(clippy::unnecessary_wraps)]
  191    158   
pub fn de_re_encrypt_http_response(
  192    159   
    _response_status: u16,
  193    160   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +201,171 @@
   20     20   
        "AlreadyExistsException" => crate::operation::replicate_key::ReplicateKeyError::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::replicate_key::ReplicateKeyError::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::replicate_key::ReplicateKeyError::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::replicate_key::ReplicateKeyError::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   
        "InvalidArnException" => crate::operation::replicate_key::ReplicateKeyError::InvalidArnException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::replicate_key::ReplicateKeyError::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::replicate_key::ReplicateKeyError::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::replicate_key::ReplicateKeyError::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::replicate_key::ReplicateKeyError::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::replicate_key::ReplicateKeyError::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::replicate_key::ReplicateKeyError::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::replicate_key::ReplicateKeyError::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   
        "MalformedPolicyDocumentException" => crate::operation::replicate_key::ReplicateKeyError::MalformedPolicyDocumentException({
  111     93   
            #[allow(unused_mut)]
  112     94   
            let mut tmp = {
  113     95   
                #[allow(unused_mut)]
  114     96   
                let mut output = crate::types::error::builders::MalformedPolicyDocumentExceptionBuilder::default();
  115     97   
                output = crate::protocol_serde::shape_malformed_policy_document_exception::de_malformed_policy_document_exception_json_err(
  116     98   
                    _response_body,
  117     99   
                    output,
  118    100   
                )
  119    101   
                .map_err(crate::operation::replicate_key::ReplicateKeyError::unhandled)?;
  120    102   
                let output = output.meta(generic);
  121    103   
                output.build()
  122    104   
            };
  123         -
            if tmp.message.is_none() {
  124         -
                tmp.message = _error_message;
  125         -
            }
  126    105   
            tmp
  127    106   
        }),
  128    107   
        "NotFoundException" => crate::operation::replicate_key::ReplicateKeyError::NotFoundException({
  129    108   
            #[allow(unused_mut)]
  130    109   
            let mut tmp = {
  131    110   
                #[allow(unused_mut)]
  132    111   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
  133    112   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
  134    113   
                    .map_err(crate::operation::replicate_key::ReplicateKeyError::unhandled)?;
  135    114   
                let output = output.meta(generic);
  136    115   
                output.build()
  137    116   
            };
  138         -
            if tmp.message.is_none() {
  139         -
                tmp.message = _error_message;
  140         -
            }
  141    117   
            tmp
  142    118   
        }),
  143    119   
        "TagException" => crate::operation::replicate_key::ReplicateKeyError::TagException({
  144    120   
            #[allow(unused_mut)]
  145    121   
            let mut tmp = {
  146    122   
                #[allow(unused_mut)]
  147    123   
                let mut output = crate::types::error::builders::TagExceptionBuilder::default();
  148    124   
                output = crate::protocol_serde::shape_tag_exception::de_tag_exception_json_err(_response_body, output)
  149    125   
                    .map_err(crate::operation::replicate_key::ReplicateKeyError::unhandled)?;
  150    126   
                let output = output.meta(generic);
  151    127   
                output.build()
  152    128   
            };
  153         -
            if tmp.message.is_none() {
  154         -
                tmp.message = _error_message;
  155         -
            }
  156    129   
            tmp
  157    130   
        }),
  158    131   
        "UnsupportedOperationException" => crate::operation::replicate_key::ReplicateKeyError::UnsupportedOperationException({
  159    132   
            #[allow(unused_mut)]
  160    133   
            let mut tmp = {
  161    134   
                #[allow(unused_mut)]
  162    135   
                let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  163    136   
                output =
  164    137   
                    crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(_response_body, output)
  165    138   
                        .map_err(crate::operation::replicate_key::ReplicateKeyError::unhandled)?;
  166    139   
                let output = output.meta(generic);
  167    140   
                output.build()
  168    141   
            };
  169         -
            if tmp.message.is_none() {
  170         -
                tmp.message = _error_message;
  171         -
            }
  172    142   
            tmp
  173    143   
        }),
  174    144   
        _ => crate::operation::replicate_key::ReplicateKeyError::generic(generic),
  175    145   
    })
  176    146   
}
  177    147   
  178    148   
#[allow(clippy::unnecessary_wraps)]
  179    149   
pub fn de_replicate_key_http_response(
  180    150   
    _response_status: u16,
  181    151   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,