AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df

Files changed:

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

@@ -1,1 +167,143 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::retire_grant::RetireGrantError::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::retire_grant::RetireGrantError::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   
        "DryRunOperationException" => crate::operation::retire_grant::RetireGrantError::DryRunOperationException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::DryRunOperationExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_dry_run_operation_exception::de_dry_run_operation_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::retire_grant::RetireGrantError::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::retire_grant::RetireGrantError::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::retire_grant::RetireGrantError::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   
        "InvalidGrantIdException" => crate::operation::retire_grant::RetireGrantError::InvalidGrantIdException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::InvalidGrantIdExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_invalid_grant_id_exception::de_invalid_grant_id_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::retire_grant::RetireGrantError::unhandled)?;
   72     63   
                let output = output.meta(generic);
   73     64   
                output.build()
   74     65   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     66   
            tmp
   79     67   
        }),
   80     68   
        "InvalidGrantTokenException" => crate::operation::retire_grant::RetireGrantError::InvalidGrantTokenException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::InvalidGrantTokenExceptionBuilder::default();
   85     73   
                output =
   86     74   
                    crate::protocol_serde::shape_invalid_grant_token_exception::de_invalid_grant_token_exception_json_err(_response_body, output)
   87     75   
                        .map_err(crate::operation::retire_grant::RetireGrantError::unhandled)?;
   88     76   
                let output = output.meta(generic);
   89     77   
                output.build()
   90     78   
            };
   91         -
            if tmp.message.is_none() {
   92         -
                tmp.message = _error_message;
   93         -
            }
   94     79   
            tmp
   95     80   
        }),
   96     81   
        "KMSInternalException" => crate::operation::retire_grant::RetireGrantError::KmsInternalException({
   97     82   
            #[allow(unused_mut)]
   98     83   
            let mut tmp = {
   99     84   
                #[allow(unused_mut)]
  100     85   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
  101     86   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
  102     87   
                    .map_err(crate::operation::retire_grant::RetireGrantError::unhandled)?;
  103     88   
                let output = output.meta(generic);
  104     89   
                output.build()
  105     90   
            };
  106         -
            if tmp.message.is_none() {
  107         -
                tmp.message = _error_message;
  108         -
            }
  109     91   
            tmp
  110     92   
        }),
  111     93   
        "KMSInvalidStateException" => crate::operation::retire_grant::RetireGrantError::KmsInvalidStateException({
  112     94   
            #[allow(unused_mut)]
  113     95   
            let mut tmp = {
  114     96   
                #[allow(unused_mut)]
  115     97   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
  116     98   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
  117     99   
                    .map_err(crate::operation::retire_grant::RetireGrantError::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   
        "NotFoundException" => crate::operation::retire_grant::RetireGrantError::NotFoundException({
  127    106   
            #[allow(unused_mut)]
  128    107   
            let mut tmp = {
  129    108   
                #[allow(unused_mut)]
  130    109   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
  131    110   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
  132    111   
                    .map_err(crate::operation::retire_grant::RetireGrantError::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   
        _ => crate::operation::retire_grant::RetireGrantError::generic(generic),
  142    118   
    })
  143    119   
}
  144    120   
  145    121   
#[allow(clippy::unnecessary_wraps)]
  146    122   
pub fn de_retire_grant_http_response(
  147    123   
    _response_status: u16,
  148    124   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +151,130 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::revoke_grant::RevokeGrantError::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::revoke_grant::RevokeGrantError::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   
        "DryRunOperationException" => crate::operation::revoke_grant::RevokeGrantError::DryRunOperationException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::DryRunOperationExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_dry_run_operation_exception::de_dry_run_operation_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::revoke_grant::RevokeGrantError::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::revoke_grant::RevokeGrantError::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::revoke_grant::RevokeGrantError::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   
        "InvalidGrantIdException" => crate::operation::revoke_grant::RevokeGrantError::InvalidGrantIdException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::InvalidGrantIdExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_invalid_grant_id_exception::de_invalid_grant_id_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::revoke_grant::RevokeGrantError::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::revoke_grant::RevokeGrantError::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::revoke_grant::RevokeGrantError::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::revoke_grant::RevokeGrantError::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::revoke_grant::RevokeGrantError::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::revoke_grant::RevokeGrantError::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::revoke_grant::RevokeGrantError::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::revoke_grant::RevokeGrantError::generic(generic),
  126    105   
    })
  127    106   
}
  128    107   
  129    108   
#[allow(clippy::unnecessary_wraps)]
  130    109   
pub fn de_revoke_grant_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_rotate_key_on_demand.rs

@@ -3,3 +186,159 @@
   23     23   
        "ConflictException" => crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::ConflictException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::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   
        "DependencyTimeoutException" => crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::DependencyTimeoutException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::DependencyTimeoutExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_dependency_timeout_exception::de_dependency_timeout_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::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   
        "DisabledException" => crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::DisabledException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::DisabledExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_disabled_exception::de_disabled_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::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   
        "InvalidArnException" => crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::InvalidArnException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::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   
        "KMSInternalException" => crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::KmsInternalException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::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   
        "KMSInvalidStateException" => crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::KmsInvalidStateException({
   99     84   
            #[allow(unused_mut)]
  100     85   
            let mut tmp = {
  101     86   
                #[allow(unused_mut)]
  102     87   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
  103     88   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
  104     89   
                    .map_err(crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::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   
        "LimitExceededException" => crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::LimitExceededException({
  114     96   
            #[allow(unused_mut)]
  115     97   
            let mut tmp = {
  116     98   
                #[allow(unused_mut)]
  117     99   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
  118    100   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
  119    101   
                    .map_err(crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::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::rotate_key_on_demand::RotateKeyOnDemandError::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::rotate_key_on_demand::RotateKeyOnDemandError::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   
        "UnsupportedOperationException" => crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::UnsupportedOperationException({
  144    120   
            #[allow(unused_mut)]
  145    121   
            let mut tmp = {
  146    122   
                #[allow(unused_mut)]
  147    123   
                let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  148    124   
                output =
  149    125   
                    crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(_response_body, output)
  150    126   
                        .map_err(crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::unhandled)?;
  151    127   
                let output = output.meta(generic);
  152    128   
                output.build()
  153    129   
            };
  154         -
            if tmp.message.is_none() {
  155         -
                tmp.message = _error_message;
  156         -
            }
  157    130   
            tmp
  158    131   
        }),
  159    132   
        _ => crate::operation::rotate_key_on_demand::RotateKeyOnDemandError::generic(generic),
  160    133   
    })
  161    134   
}
  162    135   
  163    136   
#[allow(clippy::unnecessary_wraps)]
  164    137   
pub fn de_rotate_key_on_demand_http_response(
  165    138   
    _response_status: u16,
  166    139   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +125,110 @@
   23     23   
        "DependencyTimeoutException" => crate::operation::schedule_key_deletion::ScheduleKeyDeletionError::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::schedule_key_deletion::ScheduleKeyDeletionError::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::schedule_key_deletion::ScheduleKeyDeletionError::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::schedule_key_deletion::ScheduleKeyDeletionError::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::schedule_key_deletion::ScheduleKeyDeletionError::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::schedule_key_deletion::ScheduleKeyDeletionError::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::schedule_key_deletion::ScheduleKeyDeletionError::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::schedule_key_deletion::ScheduleKeyDeletionError::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::schedule_key_deletion::ScheduleKeyDeletionError::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::schedule_key_deletion::ScheduleKeyDeletionError::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::schedule_key_deletion::ScheduleKeyDeletionError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_schedule_key_deletion_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_sign.rs

@@ -1,1 +183,156 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::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::sign::SignError::unhandled)?;
  148    124   
                let output = output.meta(generic);
  149    125   
                output.build()
  150    126   
            };
  151         -
            if tmp.message.is_none() {
  152         -
                tmp.message = _error_message;
  153         -
            }
  154    127   
            tmp
  155    128   
        }),
  156    129   
        _ => crate::operation::sign::SignError::generic(generic),
  157    130   
    })
  158    131   
}
  159    132   
  160    133   
#[allow(clippy::unnecessary_wraps)]
  161    134   
pub fn de_sign_http_response(
  162    135   
    _response_status: u16,
  163    136   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +136,118 @@
   20     20   
        "InvalidArnException" => crate::operation::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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   
        "KMSInternalException" => crate::operation::tag_resource::TagResourceError::KmsInternalException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::tag_resource::TagResourceError::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   
        "KMSInvalidStateException" => crate::operation::tag_resource::TagResourceError::KmsInvalidStateException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::tag_resource::TagResourceError::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   
        "LimitExceededException" => crate::operation::tag_resource::TagResourceError::LimitExceededException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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::tag_resource::TagResourceError::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   
        "TagException" => crate::operation::tag_resource::TagResourceError::TagException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::TagExceptionBuilder::default();
  100     85   
                output = crate::protocol_serde::shape_tag_exception::de_tag_exception_json_err(_response_body, output)
  101     86   
                    .map_err(crate::operation::tag_resource::TagResourceError::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   
        _ => crate::operation::tag_resource::TagResourceError::generic(generic),
  111     93   
    })
  112     94   
}
  113     95   
  114     96   
#[allow(clippy::unnecessary_wraps)]
  115     97   
pub fn de_tag_resource_http_response(
  116     98   
    _response_status: u16,
  117     99   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +121,106 @@
   20     20   
        "InvalidArnException" => crate::operation::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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   
        "KMSInternalException" => crate::operation::untag_resource::UntagResourceError::KmsInternalException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::untag_resource::UntagResourceError::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   
        "KMSInvalidStateException" => crate::operation::untag_resource::UntagResourceError::KmsInvalidStateException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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   
        "TagException" => crate::operation::untag_resource::UntagResourceError::TagException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::TagExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_tag_exception::de_tag_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_untag_resource_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_update_alias.rs

@@ -1,1 +121,106 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::update_alias::UpdateAliasError::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::update_alias::UpdateAliasError::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   
        "KMSInternalException" => crate::operation::update_alias::UpdateAliasError::KmsInternalException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::update_alias::UpdateAliasError::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   
        "KMSInvalidStateException" => crate::operation::update_alias::UpdateAliasError::KmsInvalidStateException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::update_alias::UpdateAliasError::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   
        "LimitExceededException" => crate::operation::update_alias::UpdateAliasError::LimitExceededException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::update_alias::UpdateAliasError::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::update_alias::UpdateAliasError::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::update_alias::UpdateAliasError::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::update_alias::UpdateAliasError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_update_alias_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_update_custom_key_store.rs

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

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

@@ -3,3 +125,110 @@
   23     23   
        "DependencyTimeoutException" => crate::operation::update_key_description::UpdateKeyDescriptionError::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::update_key_description::UpdateKeyDescriptionError::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::update_key_description::UpdateKeyDescriptionError::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::update_key_description::UpdateKeyDescriptionError::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::update_key_description::UpdateKeyDescriptionError::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::update_key_description::UpdateKeyDescriptionError::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::update_key_description::UpdateKeyDescriptionError::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::update_key_description::UpdateKeyDescriptionError::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::update_key_description::UpdateKeyDescriptionError::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::update_key_description::UpdateKeyDescriptionError::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::update_key_description::UpdateKeyDescriptionError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_update_key_description_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_update_primary_region.rs

@@ -3,3 +141,123 @@
   23     23   
        "DisabledException" => crate::operation::update_primary_region::UpdatePrimaryRegionError::DisabledException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::DisabledExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_disabled_exception::de_disabled_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::update_primary_region::UpdatePrimaryRegionError::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::update_primary_region::UpdatePrimaryRegionError::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::update_primary_region::UpdatePrimaryRegionError::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::update_primary_region::UpdatePrimaryRegionError::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::update_primary_region::UpdatePrimaryRegionError::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::update_primary_region::UpdatePrimaryRegionError::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::update_primary_region::UpdatePrimaryRegionError::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::update_primary_region::UpdatePrimaryRegionError::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::update_primary_region::UpdatePrimaryRegionError::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::update_primary_region::UpdatePrimaryRegionError::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::update_primary_region::UpdatePrimaryRegionError::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::update_primary_region::UpdatePrimaryRegionError::generic(generic),
  115     97   
    })
  116     98   
}
  117     99   
  118    100   
#[allow(clippy::unnecessary_wraps)]
  119    101   
pub fn de_update_primary_region_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_verify.rs

@@ -1,1 +199,169 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::verify::VerifyError::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::verify::VerifyError::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::verify::VerifyError::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::verify::VerifyError::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::verify::VerifyError::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::verify::VerifyError::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::verify::VerifyError::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::verify::VerifyError::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::verify::VerifyError::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::verify::VerifyError::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::verify::VerifyError::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::verify::VerifyError::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::verify::VerifyError::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::verify::VerifyError::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   
        "KMSInvalidSignatureException" => crate::operation::verify::VerifyError::KmsInvalidSignatureException({
  127    106   
            #[allow(unused_mut)]
  128    107   
            let mut tmp = {
  129    108   
                #[allow(unused_mut)]
  130    109   
                let mut output = crate::types::error::builders::KmsInvalidSignatureExceptionBuilder::default();
  131    110   
                output =
  132    111   
                    crate::protocol_serde::shape_kms_invalid_signature_exception::de_kms_invalid_signature_exception_json_err(_response_body, output)
  133    112   
                        .map_err(crate::operation::verify::VerifyError::unhandled)?;
  134    113   
                let output = output.meta(generic);
  135    114   
                output.build()
  136    115   
            };
  137         -
            if tmp.message.is_none() {
  138         -
                tmp.message = _error_message;
  139         -
            }
  140    116   
            tmp
  141    117   
        }),
  142    118   
        "KMSInvalidStateException" => crate::operation::verify::VerifyError::KmsInvalidStateException({
  143    119   
            #[allow(unused_mut)]
  144    120   
            let mut tmp = {
  145    121   
                #[allow(unused_mut)]
  146    122   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
  147    123   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
  148    124   
                    .map_err(crate::operation::verify::VerifyError::unhandled)?;
  149    125   
                let output = output.meta(generic);
  150    126   
                output.build()
  151    127   
            };
  152         -
            if tmp.message.is_none() {
  153         -
                tmp.message = _error_message;
  154         -
            }
  155    128   
            tmp
  156    129   
        }),
  157    130   
        "NotFoundException" => crate::operation::verify::VerifyError::NotFoundException({
  158    131   
            #[allow(unused_mut)]
  159    132   
            let mut tmp = {
  160    133   
                #[allow(unused_mut)]
  161    134   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
  162    135   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
  163    136   
                    .map_err(crate::operation::verify::VerifyError::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::verify::VerifyError::generic(generic),
  173    143   
    })
  174    144   
}
  175    145   
  176    146   
#[allow(clippy::unnecessary_wraps)]
  177    147   
pub fn de_verify_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_verify_mac.rs

@@ -1,1 +183,156 @@
   20     20   
        "DisabledException" => crate::operation::verify_mac::VerifyMacError::DisabledException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::DisabledExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_disabled_exception::de_disabled_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::verify_mac::VerifyMacError::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   
        "DryRunOperationException" => crate::operation::verify_mac::VerifyMacError::DryRunOperationException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::DryRunOperationExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_dry_run_operation_exception::de_dry_run_operation_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::verify_mac::VerifyMacError::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   
        "InvalidGrantTokenException" => crate::operation::verify_mac::VerifyMacError::InvalidGrantTokenException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidGrantTokenExceptionBuilder::default();
   55     49   
                output =
   56     50   
                    crate::protocol_serde::shape_invalid_grant_token_exception::de_invalid_grant_token_exception_json_err(_response_body, output)
   57     51   
                        .map_err(crate::operation::verify_mac::VerifyMacError::unhandled)?;
   58     52   
                let output = output.meta(generic);
   59     53   
                output.build()
   60     54   
            };
   61         -
            if tmp.message.is_none() {
   62         -
                tmp.message = _error_message;
   63         -
            }
   64     55   
            tmp
   65     56   
        }),
   66     57   
        "InvalidKeyUsageException" => crate::operation::verify_mac::VerifyMacError::InvalidKeyUsageException({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::InvalidKeyUsageExceptionBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_invalid_key_usage_exception::de_invalid_key_usage_exception_json_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::verify_mac::VerifyMacError::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   
        "KeyUnavailableException" => crate::operation::verify_mac::VerifyMacError::KeyUnavailableException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::KeyUnavailableExceptionBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_key_unavailable_exception::de_key_unavailable_exception_json_err(_response_body, output)
   87     75   
                    .map_err(crate::operation::verify_mac::VerifyMacError::unhandled)?;
   88     76   
                let output = output.meta(generic);
   89     77   
                output.build()
   90     78   
            };
   91         -
            if tmp.message.is_none() {
   92         -
                tmp.message = _error_message;
   93         -
            }
   94     79   
            tmp
   95     80   
        }),
   96     81   
        "KMSInternalException" => crate::operation::verify_mac::VerifyMacError::KmsInternalException({
   97     82   
            #[allow(unused_mut)]
   98     83   
            let mut tmp = {
   99     84   
                #[allow(unused_mut)]
  100     85   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
  101     86   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
  102     87   
                    .map_err(crate::operation::verify_mac::VerifyMacError::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   
        "KMSInvalidMacException" => crate::operation::verify_mac::VerifyMacError::KmsInvalidMacException({
  112     94   
            #[allow(unused_mut)]
  113     95   
            let mut tmp = {
  114     96   
                #[allow(unused_mut)]
  115     97   
                let mut output = crate::types::error::builders::KmsInvalidMacExceptionBuilder::default();
  116     98   
                output = crate::protocol_serde::shape_kms_invalid_mac_exception::de_kms_invalid_mac_exception_json_err(_response_body, output)
  117     99   
                    .map_err(crate::operation::verify_mac::VerifyMacError::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::verify_mac::VerifyMacError::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::verify_mac::VerifyMacError::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::verify_mac::VerifyMacError::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::verify_mac::VerifyMacError::unhandled)?;
  148    124   
                let output = output.meta(generic);
  149    125   
                output.build()
  150    126   
            };
  151         -
            if tmp.message.is_none() {
  152         -
                tmp.message = _error_message;
  153         -
            }
  154    127   
            tmp
  155    128   
        }),
  156    129   
        _ => crate::operation::verify_mac::VerifyMacError::generic(generic),
  157    130   
    })
  158    131   
}
  159    132   
  160    133   
#[allow(clippy::unnecessary_wraps)]
  161    134   
pub fn de_verify_mac_http_response(
  162    135   
    _response_status: u16,
  163    136   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_add_layer_version_permission.rs

@@ -11,11 +179,158 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::unhandled)?;
   38     38   
                    let output = output.meta(generic);
   39     39   
                    output.build()
   40     40   
                };
   41         -
                if tmp.message.is_none() {
   42         -
                    tmp.message = _error_message;
   43         -
                }
   44     41   
                tmp
   45     42   
            })
   46     43   
        }
   47     44   
        "PolicyLengthExceededException" => {
   48     45   
            crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::PolicyLengthExceededException({
   49     46   
                #[allow(unused_mut)]
   50     47   
                let mut tmp = {
   51     48   
                    #[allow(unused_mut)]
   52     49   
                    let mut output = crate::types::error::builders::PolicyLengthExceededExceptionBuilder::default();
   53     50   
                    output = crate::protocol_serde::shape_policy_length_exceeded_exception::de_policy_length_exceeded_exception_json_err(
   54     51   
                        _response_body,
   55     52   
                        output,
   56     53   
                    )
   57     54   
                    .map_err(crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::unhandled)?;
   58     55   
                    let output = output.meta(generic);
   59     56   
                    output.build()
   60     57   
                };
   61         -
                if tmp.message.is_none() {
   62         -
                    tmp.message = _error_message;
   63         -
                }
   64     58   
                tmp
   65     59   
            })
   66     60   
        }
   67     61   
        "PreconditionFailedException" => {
   68     62   
            crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::PreconditionFailedException({
   69     63   
                #[allow(unused_mut)]
   70     64   
                let mut tmp = {
   71     65   
                    #[allow(unused_mut)]
   72     66   
                    let mut output = crate::types::error::builders::PreconditionFailedExceptionBuilder::default();
   73     67   
                    output =
   74     68   
                        crate::protocol_serde::shape_precondition_failed_exception::de_precondition_failed_exception_json_err(_response_body, output)
   75     69   
                            .map_err(crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::unhandled)?;
   76     70   
                    let output = output.meta(generic);
   77     71   
                    output.build()
   78     72   
                };
   79         -
                if tmp.message.is_none() {
   80         -
                    tmp.message = _error_message;
   81         -
                }
   82     73   
                tmp
   83     74   
            })
   84     75   
        }
   85     76   
        "ResourceConflictException" => crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::ResourceConflictException({
   86     77   
            #[allow(unused_mut)]
   87     78   
            let mut tmp = {
   88     79   
                #[allow(unused_mut)]
   89     80   
                let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   90     81   
                output = crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   91     82   
                    .map_err(crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::unhandled)?;
   92     83   
                let output = output.meta(generic);
   93     84   
                output.build()
   94     85   
            };
   95         -
            if tmp.message.is_none() {
   96         -
                tmp.message = _error_message;
   97         -
            }
   98     86   
            tmp
   99     87   
        }),
  100     88   
        "ResourceNotFoundException" => crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::ResourceNotFoundException({
  101     89   
            #[allow(unused_mut)]
  102     90   
            let mut tmp = {
  103     91   
                #[allow(unused_mut)]
  104     92   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
  105     93   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  106     94   
                    .map_err(crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::unhandled)?;
  107     95   
                let output = output.meta(generic);
  108     96   
                output.build()
  109     97   
            };
  110         -
            if tmp.message.is_none() {
  111         -
                tmp.message = _error_message;
  112         -
            }
  113     98   
            tmp
  114     99   
        }),
  115    100   
        "ServiceException" => crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::ServiceException({
  116    101   
            #[allow(unused_mut)]
  117    102   
            let mut tmp = {
  118    103   
                #[allow(unused_mut)]
  119    104   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
  120    105   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
  121    106   
                    .map_err(crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::unhandled)?;
  122    107   
                let output = output.meta(generic);
  123    108   
                output.build()
  124    109   
            };
  125         -
            if tmp.message.is_none() {
  126         -
                tmp.message = _error_message;
  127         -
            }
  128    110   
            tmp
  129    111   
        }),
  130    112   
        "TooManyRequestsException" => crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::TooManyRequestsException({
  131    113   
            #[allow(unused_mut)]
  132    114   
            let mut tmp = {
  133    115   
                #[allow(unused_mut)]
  134    116   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
  135    117   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
  136    118   
                    .map_err(crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::unhandled)?;
  137    119   
                output = output.set_retry_after_seconds(
  138    120   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
  139    121   
                        crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::unhandled(
  140    122   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
  141    123   
                        )
  142    124   
                    })?,
  143    125   
                );
  144    126   
                let output = output.meta(generic);
  145    127   
                output.build()
  146    128   
            };
  147         -
            if tmp.message.is_none() {
  148         -
                tmp.message = _error_message;
  149         -
            }
  150    129   
            tmp
  151    130   
        }),
  152    131   
        _ => crate::operation::add_layer_version_permission::AddLayerVersionPermissionError::generic(generic),
  153    132   
    })
  154    133   
}
  155    134   
  156    135   
#[allow(clippy::unnecessary_wraps)]
  157    136   
pub fn de_add_layer_version_permission_http_response(
  158    137   
    _response_status: u16,
  159    138   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_add_permission.rs

@@ -3,3 +164,143 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::add_permission::AddPermissionError::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   
        "PolicyLengthExceededException" => crate::operation::add_permission::AddPermissionError::PolicyLengthExceededException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::PolicyLengthExceededExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_policy_length_exceeded_exception::de_policy_length_exceeded_exception_json_err(
   44     41   
                    _response_body,
   45     42   
                    output,
   46     43   
                )
   47     44   
                .map_err(crate::operation::add_permission::AddPermissionError::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   
        "PreconditionFailedException" => crate::operation::add_permission::AddPermissionError::PreconditionFailedException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::PreconditionFailedExceptionBuilder::default();
   61     55   
                output =
   62     56   
                    crate::protocol_serde::shape_precondition_failed_exception::de_precondition_failed_exception_json_err(_response_body, output)
   63     57   
                        .map_err(crate::operation::add_permission::AddPermissionError::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   
        "ResourceConflictException" => crate::operation::add_permission::AddPermissionError::ResourceConflictException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::add_permission::AddPermissionError::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   
        "ResourceNotFoundException" => crate::operation::add_permission::AddPermissionError::ResourceNotFoundException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::add_permission::AddPermissionError::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   
        "ServiceException" => crate::operation::add_permission::AddPermissionError::ServiceException({
  103     88   
            #[allow(unused_mut)]
  104     89   
            let mut tmp = {
  105     90   
                #[allow(unused_mut)]
  106     91   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
  107     92   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
  108     93   
                    .map_err(crate::operation::add_permission::AddPermissionError::unhandled)?;
  109     94   
                let output = output.meta(generic);
  110     95   
                output.build()
  111     96   
            };
  112         -
            if tmp.message.is_none() {
  113         -
                tmp.message = _error_message;
  114         -
            }
  115     97   
            tmp
  116     98   
        }),
  117     99   
        "TooManyRequestsException" => crate::operation::add_permission::AddPermissionError::TooManyRequestsException({
  118    100   
            #[allow(unused_mut)]
  119    101   
            let mut tmp = {
  120    102   
                #[allow(unused_mut)]
  121    103   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
  122    104   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
  123    105   
                    .map_err(crate::operation::add_permission::AddPermissionError::unhandled)?;
  124    106   
                output = output.set_retry_after_seconds(
  125    107   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
  126    108   
                        crate::operation::add_permission::AddPermissionError::unhandled("Failed to parse retryAfterSeconds from header `Retry-After")
  127    109   
                    })?,
  128    110   
                );
  129    111   
                let output = output.meta(generic);
  130    112   
                output.build()
  131    113   
            };
  132         -
            if tmp.message.is_none() {
  133         -
                tmp.message = _error_message;
  134         -
            }
  135    114   
            tmp
  136    115   
        }),
  137    116   
        _ => crate::operation::add_permission::AddPermissionError::generic(generic),
  138    117   
    })
  139    118   
}
  140    119   
  141    120   
#[allow(clippy::unnecessary_wraps)]
  142    121   
pub fn de_add_permission_http_response(
  143    122   
    _response_status: u16,
  144    123   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +130,115 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::create_alias::CreateAliasError::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   
        "ResourceConflictException" => crate::operation::create_alias::CreateAliasError::ResourceConflictException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::create_alias::CreateAliasError::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   
        "ResourceNotFoundException" => crate::operation::create_alias::CreateAliasError::ResourceNotFoundException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::create_alias::CreateAliasError::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   
        "ServiceException" => crate::operation::create_alias::CreateAliasError::ServiceException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::create_alias::CreateAliasError::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   
        "TooManyRequestsException" => crate::operation::create_alias::CreateAliasError::TooManyRequestsException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::create_alias::CreateAliasError::unhandled)?;
   90     78   
                output = output.set_retry_after_seconds(
   91     79   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   92     80   
                        crate::operation::create_alias::CreateAliasError::unhandled("Failed to parse retryAfterSeconds from header `Retry-After")
   93     81   
                    })?,
   94     82   
                );
   95     83   
                let output = output.meta(generic);
   96     84   
                output.build()
   97     85   
            };
   98         -
            if tmp.message.is_none() {
   99         -
                tmp.message = _error_message;
  100         -
            }
  101     86   
            tmp
  102     87   
        }),
  103     88   
        _ => crate::operation::create_alias::CreateAliasError::generic(generic),
  104     89   
    })
  105     90   
}
  106     91   
  107     92   
#[allow(clippy::unnecessary_wraps)]
  108     93   
pub fn de_create_alias_http_response(
  109     94   
    _response_status: u16,
  110     95   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,