AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df

Files changed:

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

@@ -1,1 +106,94 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::delete_alias::DeleteAliasError::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::delete_alias::DeleteAliasError::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::delete_alias::DeleteAliasError::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::delete_alias::DeleteAliasError::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::delete_alias::DeleteAliasError::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::delete_alias::DeleteAliasError::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::delete_alias::DeleteAliasError::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::delete_alias::DeleteAliasError::unhandled)?;
   72     63   
                let output = output.meta(generic);
   73     64   
                output.build()
   74     65   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     66   
            tmp
   79     67   
        }),
   80     68   
        _ => crate::operation::delete_alias::DeleteAliasError::generic(generic),
   81     69   
    })
   82     70   
}
   83     71   
   84     72   
#[allow(clippy::unnecessary_wraps)]
   85     73   
pub fn de_delete_alias_http_response(
   86     74   
    _response_status: u16,
   87     75   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -6,6 +122,110 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::CustomKeyStoreHasCmKsExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_custom_key_store_has_cmks_exception::de_custom_key_store_has_cmks_exception_json_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::delete_custom_key_store::DeleteCustomKeyStoreError::unhandled)?;
   33     33   
                let output = output.meta(generic);
   34     34   
                output.build()
   35     35   
            };
   36         -
            if tmp.message.is_none() {
   37         -
                tmp.message = _error_message;
   38         -
            }
   39     36   
            tmp
   40     37   
        }),
   41     38   
        "CustomKeyStoreInvalidStateException" => {
   42     39   
            crate::operation::delete_custom_key_store::DeleteCustomKeyStoreError::CustomKeyStoreInvalidStateException({
   43     40   
                #[allow(unused_mut)]
   44     41   
                let mut tmp = {
   45     42   
                    #[allow(unused_mut)]
   46     43   
                    let mut output = crate::types::error::builders::CustomKeyStoreInvalidStateExceptionBuilder::default();
   47     44   
                    output =
   48     45   
                        crate::protocol_serde::shape_custom_key_store_invalid_state_exception::de_custom_key_store_invalid_state_exception_json_err(
   49     46   
                            _response_body,
   50     47   
                            output,
   51     48   
                        )
   52     49   
                        .map_err(crate::operation::delete_custom_key_store::DeleteCustomKeyStoreError::unhandled)?;
   53     50   
                    let output = output.meta(generic);
   54     51   
                    output.build()
   55     52   
                };
   56         -
                if tmp.message.is_none() {
   57         -
                    tmp.message = _error_message;
   58         -
                }
   59     53   
                tmp
   60     54   
            })
   61     55   
        }
   62     56   
        "CustomKeyStoreNotFoundException" => crate::operation::delete_custom_key_store::DeleteCustomKeyStoreError::CustomKeyStoreNotFoundException({
   63     57   
            #[allow(unused_mut)]
   64     58   
            let mut tmp = {
   65     59   
                #[allow(unused_mut)]
   66     60   
                let mut output = crate::types::error::builders::CustomKeyStoreNotFoundExceptionBuilder::default();
   67     61   
                output = crate::protocol_serde::shape_custom_key_store_not_found_exception::de_custom_key_store_not_found_exception_json_err(
   68     62   
                    _response_body,
   69     63   
                    output,
   70     64   
                )
   71     65   
                .map_err(crate::operation::delete_custom_key_store::DeleteCustomKeyStoreError::unhandled)?;
   72     66   
                let output = output.meta(generic);
   73     67   
                output.build()
   74     68   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     69   
            tmp
   79     70   
        }),
   80     71   
        "KMSInternalException" => crate::operation::delete_custom_key_store::DeleteCustomKeyStoreError::KmsInternalException({
   81     72   
            #[allow(unused_mut)]
   82     73   
            let mut tmp = {
   83     74   
                #[allow(unused_mut)]
   84     75   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   85     76   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   86     77   
                    .map_err(crate::operation::delete_custom_key_store::DeleteCustomKeyStoreError::unhandled)?;
   87     78   
                let output = output.meta(generic);
   88     79   
                output.build()
   89     80   
            };
   90         -
            if tmp.message.is_none() {
   91         -
                tmp.message = _error_message;
   92         -
            }
   93     81   
            tmp
   94     82   
        }),
   95     83   
        _ => crate::operation::delete_custom_key_store::DeleteCustomKeyStoreError::generic(generic),
   96     84   
    })
   97     85   
}
   98     86   
   99     87   
#[allow(clippy::unnecessary_wraps)]
  100     88   
pub fn de_delete_custom_key_store_http_response(
  101     89   
    _response_status: u16,
  102     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +148,130 @@
   27     27   
        "DependencyTimeoutException" => crate::operation::delete_imported_key_material::DeleteImportedKeyMaterialError::DependencyTimeoutException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::DependencyTimeoutExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_dependency_timeout_exception::de_dependency_timeout_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::delete_imported_key_material::DeleteImportedKeyMaterialError::unhandled)?;
   34     34   
                let output = output.meta(generic);
   35     35   
                output.build()
   36     36   
            };
   37         -
            if tmp.message.is_none() {
   38         -
                tmp.message = _error_message;
   39         -
            }
   40     37   
            tmp
   41     38   
        }),
   42     39   
        "InvalidArnException" => crate::operation::delete_imported_key_material::DeleteImportedKeyMaterialError::InvalidArnException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::delete_imported_key_material::DeleteImportedKeyMaterialError::unhandled)?;
   49     46   
                let output = output.meta(generic);
   50     47   
                output.build()
   51     48   
            };
   52         -
            if tmp.message.is_none() {
   53         -
                tmp.message = _error_message;
   54         -
            }
   55     49   
            tmp
   56     50   
        }),
   57     51   
        "KMSInternalException" => crate::operation::delete_imported_key_material::DeleteImportedKeyMaterialError::KmsInternalException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::delete_imported_key_material::DeleteImportedKeyMaterialError::unhandled)?;
   64     58   
                let output = output.meta(generic);
   65     59   
                output.build()
   66     60   
            };
   67         -
            if tmp.message.is_none() {
   68         -
                tmp.message = _error_message;
   69         -
            }
   70     61   
            tmp
   71     62   
        }),
   72     63   
        "KMSInvalidStateException" => crate::operation::delete_imported_key_material::DeleteImportedKeyMaterialError::KmsInvalidStateException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::delete_imported_key_material::DeleteImportedKeyMaterialError::unhandled)?;
   79     70   
                let output = output.meta(generic);
   80     71   
                output.build()
   81     72   
            };
   82         -
            if tmp.message.is_none() {
   83         -
                tmp.message = _error_message;
   84         -
            }
   85     73   
            tmp
   86     74   
        }),
   87     75   
        "NotFoundException" => crate::operation::delete_imported_key_material::DeleteImportedKeyMaterialError::NotFoundException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::delete_imported_key_material::DeleteImportedKeyMaterialError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        "UnsupportedOperationException" => {
  103     88   
            crate::operation::delete_imported_key_material::DeleteImportedKeyMaterialError::UnsupportedOperationException({
  104     89   
                #[allow(unused_mut)]
  105     90   
                let mut tmp = {
  106     91   
                    #[allow(unused_mut)]
  107     92   
                    let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  108     93   
                    output = crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(
  109     94   
                        _response_body,
  110     95   
                        output,
  111     96   
                    )
  112     97   
                    .map_err(crate::operation::delete_imported_key_material::DeleteImportedKeyMaterialError::unhandled)?;
  113     98   
                    let output = output.meta(generic);
  114     99   
                    output.build()
  115    100   
                };
  116         -
                if tmp.message.is_none() {
  117         -
                    tmp.message = _error_message;
  118         -
                }
  119    101   
                tmp
  120    102   
            })
  121    103   
        }
  122    104   
        _ => crate::operation::delete_imported_key_material::DeleteImportedKeyMaterialError::generic(generic),
  123    105   
    })
  124    106   
}
  125    107   
  126    108   
#[allow(clippy::unnecessary_wraps)]
  127    109   
pub fn de_delete_imported_key_material_http_response(
  128    110   
    _response_status: u16,

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

@@ -11,11 +104,95 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::CustomKeyStoreNotFoundExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_custom_key_store_not_found_exception::de_custom_key_store_not_found_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::describe_custom_key_stores::DescribeCustomKeyStoresError::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   
        "InvalidMarkerException" => crate::operation::describe_custom_key_stores::DescribeCustomKeyStoresError::InvalidMarkerException({
   48     45   
            #[allow(unused_mut)]
   49     46   
            let mut tmp = {
   50     47   
                #[allow(unused_mut)]
   51     48   
                let mut output = crate::types::error::builders::InvalidMarkerExceptionBuilder::default();
   52     49   
                output = crate::protocol_serde::shape_invalid_marker_exception::de_invalid_marker_exception_json_err(_response_body, output)
   53     50   
                    .map_err(crate::operation::describe_custom_key_stores::DescribeCustomKeyStoresError::unhandled)?;
   54     51   
                let output = output.meta(generic);
   55     52   
                output.build()
   56     53   
            };
   57         -
            if tmp.message.is_none() {
   58         -
                tmp.message = _error_message;
   59         -
            }
   60     54   
            tmp
   61     55   
        }),
   62     56   
        "KMSInternalException" => crate::operation::describe_custom_key_stores::DescribeCustomKeyStoresError::KmsInternalException({
   63     57   
            #[allow(unused_mut)]
   64     58   
            let mut tmp = {
   65     59   
                #[allow(unused_mut)]
   66     60   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   67     61   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   68     62   
                    .map_err(crate::operation::describe_custom_key_stores::DescribeCustomKeyStoresError::unhandled)?;
   69     63   
                let output = output.meta(generic);
   70     64   
                output.build()
   71     65   
            };
   72         -
            if tmp.message.is_none() {
   73         -
                tmp.message = _error_message;
   74         -
            }
   75     66   
            tmp
   76     67   
        }),
   77     68   
        _ => crate::operation::describe_custom_key_stores::DescribeCustomKeyStoresError::generic(generic),
   78     69   
    })
   79     70   
}
   80     71   
   81     72   
#[allow(clippy::unnecessary_wraps)]
   82     73   
pub fn de_describe_custom_key_stores_http_response(
   83     74   
    _response_status: u16,
   84     75   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +107,95 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::describe_key::DescribeKeyError::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::describe_key::DescribeKeyError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "InvalidArnException" => crate::operation::describe_key::DescribeKeyError::InvalidArnException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::describe_key::DescribeKeyError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "KMSInternalException" => crate::operation::describe_key::DescribeKeyError::KmsInternalException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::describe_key::DescribeKeyError::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::describe_key::DescribeKeyError::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::describe_key::DescribeKeyError::unhandled)?;
   72     63   
                let output = output.meta(generic);
   73     64   
                output.build()
   74     65   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     66   
            tmp
   79     67   
        }),
   80     68   
        _ => crate::operation::describe_key::DescribeKeyError::generic(generic),
   81     69   
    })
   82     70   
}
   83     71   
   84     72   
#[allow(clippy::unnecessary_wraps)]
   85     73   
pub fn de_describe_key_http_response(
   86     74   
    _response_status: u16,
   87     75   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +121,106 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::disable_key::DisableKeyError::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::disable_key::DisableKeyError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "InvalidArnException" => crate::operation::disable_key::DisableKeyError::InvalidArnException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::disable_key::DisableKeyError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "KMSInternalException" => crate::operation::disable_key::DisableKeyError::KmsInternalException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::disable_key::DisableKeyError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "KMSInvalidStateException" => crate::operation::disable_key::DisableKeyError::KmsInvalidStateException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::disable_key::DisableKeyError::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::disable_key::DisableKeyError::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::disable_key::DisableKeyError::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::disable_key::DisableKeyError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_disable_key_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_disable_key_rotation.rs

@@ -3,3 +156,135 @@
   23     23   
        "DependencyTimeoutException" => crate::operation::disable_key_rotation::DisableKeyRotationError::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::disable_key_rotation::DisableKeyRotationError::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   
        "DisabledException" => crate::operation::disable_key_rotation::DisableKeyRotationError::DisabledException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::DisabledExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_disabled_exception::de_disabled_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::disable_key_rotation::DisableKeyRotationError::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   
        "InvalidArnException" => crate::operation::disable_key_rotation::DisableKeyRotationError::InvalidArnException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::disable_key_rotation::DisableKeyRotationError::unhandled)?;
   60     54   
                let output = output.meta(generic);
   61     55   
                output.build()
   62     56   
            };
   63         -
            if tmp.message.is_none() {
   64         -
                tmp.message = _error_message;
   65         -
            }
   66     57   
            tmp
   67     58   
        }),
   68     59   
        "KMSInternalException" => crate::operation::disable_key_rotation::DisableKeyRotationError::KmsInternalException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::disable_key_rotation::DisableKeyRotationError::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   
        "KMSInvalidStateException" => crate::operation::disable_key_rotation::DisableKeyRotationError::KmsInvalidStateException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::disable_key_rotation::DisableKeyRotationError::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   
        "NotFoundException" => crate::operation::disable_key_rotation::DisableKeyRotationError::NotFoundException({
   99     84   
            #[allow(unused_mut)]
  100     85   
            let mut tmp = {
  101     86   
                #[allow(unused_mut)]
  102     87   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
  103     88   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
  104     89   
                    .map_err(crate::operation::disable_key_rotation::DisableKeyRotationError::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   
        "UnsupportedOperationException" => crate::operation::disable_key_rotation::DisableKeyRotationError::UnsupportedOperationException({
  114     96   
            #[allow(unused_mut)]
  115     97   
            let mut tmp = {
  116     98   
                #[allow(unused_mut)]
  117     99   
                let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  118    100   
                output =
  119    101   
                    crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(_response_body, output)
  120    102   
                        .map_err(crate::operation::disable_key_rotation::DisableKeyRotationError::unhandled)?;
  121    103   
                let output = output.meta(generic);
  122    104   
                output.build()
  123    105   
            };
  124         -
            if tmp.message.is_none() {
  125         -
                tmp.message = _error_message;
  126         -
            }
  127    106   
            tmp
  128    107   
        }),
  129    108   
        _ => crate::operation::disable_key_rotation::DisableKeyRotationError::generic(generic),
  130    109   
    })
  131    110   
}
  132    111   
  133    112   
#[allow(clippy::unnecessary_wraps)]
  134    113   
pub fn de_disable_key_rotation_http_response(
  135    114   
    _response_status: u16,
  136    115   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -12,12 +110,101 @@
   32     32   
                    let mut output = crate::types::error::builders::CustomKeyStoreInvalidStateExceptionBuilder::default();
   33     33   
                    output =
   34     34   
                        crate::protocol_serde::shape_custom_key_store_invalid_state_exception::de_custom_key_store_invalid_state_exception_json_err(
   35     35   
                            _response_body,
   36     36   
                            output,
   37     37   
                        )
   38     38   
                        .map_err(crate::operation::disconnect_custom_key_store::DisconnectCustomKeyStoreError::unhandled)?;
   39     39   
                    let output = output.meta(generic);
   40     40   
                    output.build()
   41     41   
                };
   42         -
                if tmp.message.is_none() {
   43         -
                    tmp.message = _error_message;
   44         -
                }
   45     42   
                tmp
   46     43   
            })
   47     44   
        }
   48     45   
        "CustomKeyStoreNotFoundException" => {
   49     46   
            crate::operation::disconnect_custom_key_store::DisconnectCustomKeyStoreError::CustomKeyStoreNotFoundException({
   50     47   
                #[allow(unused_mut)]
   51     48   
                let mut tmp = {
   52     49   
                    #[allow(unused_mut)]
   53     50   
                    let mut output = crate::types::error::builders::CustomKeyStoreNotFoundExceptionBuilder::default();
   54     51   
                    output = crate::protocol_serde::shape_custom_key_store_not_found_exception::de_custom_key_store_not_found_exception_json_err(
   55     52   
                        _response_body,
   56     53   
                        output,
   57     54   
                    )
   58     55   
                    .map_err(crate::operation::disconnect_custom_key_store::DisconnectCustomKeyStoreError::unhandled)?;
   59     56   
                    let output = output.meta(generic);
   60     57   
                    output.build()
   61     58   
                };
   62         -
                if tmp.message.is_none() {
   63         -
                    tmp.message = _error_message;
   64         -
                }
   65     59   
                tmp
   66     60   
            })
   67     61   
        }
   68     62   
        "KMSInternalException" => crate::operation::disconnect_custom_key_store::DisconnectCustomKeyStoreError::KmsInternalException({
   69     63   
            #[allow(unused_mut)]
   70     64   
            let mut tmp = {
   71     65   
                #[allow(unused_mut)]
   72     66   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   73     67   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   74     68   
                    .map_err(crate::operation::disconnect_custom_key_store::DisconnectCustomKeyStoreError::unhandled)?;
   75     69   
                let output = output.meta(generic);
   76     70   
                output.build()
   77     71   
            };
   78         -
            if tmp.message.is_none() {
   79         -
                tmp.message = _error_message;
   80         -
            }
   81     72   
            tmp
   82     73   
        }),
   83     74   
        _ => crate::operation::disconnect_custom_key_store::DisconnectCustomKeyStoreError::generic(generic),
   84     75   
    })
   85     76   
}
   86     77   
   87     78   
#[allow(clippy::unnecessary_wraps)]
   88     79   
pub fn de_disconnect_custom_key_store_http_response(
   89     80   
    _response_status: u16,
   90     81   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +136,118 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::enable_key::EnableKeyError::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::enable_key::EnableKeyError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "InvalidArnException" => crate::operation::enable_key::EnableKeyError::InvalidArnException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::enable_key::EnableKeyError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "KMSInternalException" => crate::operation::enable_key::EnableKeyError::KmsInternalException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::enable_key::EnableKeyError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "KMSInvalidStateException" => crate::operation::enable_key::EnableKeyError::KmsInvalidStateException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::enable_key::EnableKeyError::unhandled)?;
   72     63   
                let output = output.meta(generic);
   73     64   
                output.build()
   74     65   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     66   
            tmp
   79     67   
        }),
   80     68   
        "LimitExceededException" => crate::operation::enable_key::EnableKeyError::LimitExceededException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::enable_key::EnableKeyError::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   
        "NotFoundException" => crate::operation::enable_key::EnableKeyError::NotFoundException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
  100     85   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
  101     86   
                    .map_err(crate::operation::enable_key::EnableKeyError::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::enable_key::EnableKeyError::generic(generic),
  111     93   
    })
  112     94   
}
  113     95   
  114     96   
#[allow(clippy::unnecessary_wraps)]
  115     97   
pub fn de_enable_key_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_enable_key_rotation.rs

@@ -1,1 +154,133 @@
   21     21   
        "DependencyTimeoutException" => crate::operation::enable_key_rotation::EnableKeyRotationError::DependencyTimeoutException({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::DependencyTimeoutExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_dependency_timeout_exception::de_dependency_timeout_exception_json_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::enable_key_rotation::EnableKeyRotationError::unhandled)?;
   28     28   
                let output = output.meta(generic);
   29     29   
                output.build()
   30     30   
            };
   31         -
            if tmp.message.is_none() {
   32         -
                tmp.message = _error_message;
   33         -
            }
   34     31   
            tmp
   35     32   
        }),
   36     33   
        "DisabledException" => crate::operation::enable_key_rotation::EnableKeyRotationError::DisabledException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::DisabledExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_disabled_exception::de_disabled_exception_json_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::enable_key_rotation::EnableKeyRotationError::unhandled)?;
   43     40   
                let output = output.meta(generic);
   44     41   
                output.build()
   45     42   
            };
   46         -
            if tmp.message.is_none() {
   47         -
                tmp.message = _error_message;
   48         -
            }
   49     43   
            tmp
   50     44   
        }),
   51     45   
        "InvalidArnException" => crate::operation::enable_key_rotation::EnableKeyRotationError::InvalidArnException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::InvalidArnExceptionBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_invalid_arn_exception::de_invalid_arn_exception_json_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::enable_key_rotation::EnableKeyRotationError::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   
        "KMSInternalException" => crate::operation::enable_key_rotation::EnableKeyRotationError::KmsInternalException({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::enable_key_rotation::EnableKeyRotationError::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   
        "KMSInvalidStateException" => crate::operation::enable_key_rotation::EnableKeyRotationError::KmsInvalidStateException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
   87     75   
                    .map_err(crate::operation::enable_key_rotation::EnableKeyRotationError::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   
        "NotFoundException" => crate::operation::enable_key_rotation::EnableKeyRotationError::NotFoundException({
   97     82   
            #[allow(unused_mut)]
   98     83   
            let mut tmp = {
   99     84   
                #[allow(unused_mut)]
  100     85   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
  101     86   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
  102     87   
                    .map_err(crate::operation::enable_key_rotation::EnableKeyRotationError::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   
        "UnsupportedOperationException" => crate::operation::enable_key_rotation::EnableKeyRotationError::UnsupportedOperationException({
  112     94   
            #[allow(unused_mut)]
  113     95   
            let mut tmp = {
  114     96   
                #[allow(unused_mut)]
  115     97   
                let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  116     98   
                output =
  117     99   
                    crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(_response_body, output)
  118    100   
                        .map_err(crate::operation::enable_key_rotation::EnableKeyRotationError::unhandled)?;
  119    101   
                let output = output.meta(generic);
  120    102   
                output.build()
  121    103   
            };
  122         -
            if tmp.message.is_none() {
  123         -
                tmp.message = _error_message;
  124         -
            }
  125    104   
            tmp
  126    105   
        }),
  127    106   
        _ => crate::operation::enable_key_rotation::EnableKeyRotationError::generic(generic),
  128    107   
    })
  129    108   
}
  130    109   
  131    110   
#[allow(clippy::unnecessary_wraps)]
  132    111   
pub fn de_enable_key_rotation_http_response(
  133    112   
    _response_status: u16,
  134    113   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +183,156 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::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::encrypt::EncryptError::generic(generic),
  157    130   
    })
  158    131   
}
  159    132   
  160    133   
#[allow(clippy::unnecessary_wraps)]
  161    134   
pub fn de_encrypt_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_generate_data_key.rs

@@ -1,1 +183,156 @@
   20     20   
        "DependencyTimeoutException" => crate::operation::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::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::generate_data_key::GenerateDataKeyError::generic(generic),
  157    130   
    })
  158    131   
}
  159    132   
  160    133   
#[allow(clippy::unnecessary_wraps)]
  161    134   
pub fn de_generate_data_key_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_generate_data_key_pair.rs

@@ -3,3 +202,172 @@
   23     23   
        "DependencyTimeoutException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::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::generate_data_key_pair::GenerateDataKeyPairError::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   
        "DisabledException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::DisabledException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::DisabledExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_disabled_exception::de_disabled_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::generate_data_key_pair::GenerateDataKeyPairError::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   
        "DryRunOperationException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::DryRunOperationException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::DryRunOperationExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_dry_run_operation_exception::de_dry_run_operation_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::generate_data_key_pair::GenerateDataKeyPairError::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   
        "InvalidGrantTokenException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::InvalidGrantTokenException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::InvalidGrantTokenExceptionBuilder::default();
   73     64   
                output =
   74     65   
                    crate::protocol_serde::shape_invalid_grant_token_exception::de_invalid_grant_token_exception_json_err(_response_body, output)
   75     66   
                        .map_err(crate::operation::generate_data_key_pair::GenerateDataKeyPairError::unhandled)?;
   76     67   
                let output = output.meta(generic);
   77     68   
                output.build()
   78     69   
            };
   79         -
            if tmp.message.is_none() {
   80         -
                tmp.message = _error_message;
   81         -
            }
   82     70   
            tmp
   83     71   
        }),
   84     72   
        "InvalidKeyUsageException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::InvalidKeyUsageException({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::InvalidKeyUsageExceptionBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_invalid_key_usage_exception::de_invalid_key_usage_exception_json_err(_response_body, output)
   90     78   
                    .map_err(crate::operation::generate_data_key_pair::GenerateDataKeyPairError::unhandled)?;
   91     79   
                let output = output.meta(generic);
   92     80   
                output.build()
   93     81   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     82   
            tmp
   98     83   
        }),
   99     84   
        "KeyUnavailableException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::KeyUnavailableException({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::KeyUnavailableExceptionBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_key_unavailable_exception::de_key_unavailable_exception_json_err(_response_body, output)
  105     90   
                    .map_err(crate::operation::generate_data_key_pair::GenerateDataKeyPairError::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   
        "KMSInternalException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::KmsInternalException({
  115     97   
            #[allow(unused_mut)]
  116     98   
            let mut tmp = {
  117     99   
                #[allow(unused_mut)]
  118    100   
                let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
  119    101   
                output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
  120    102   
                    .map_err(crate::operation::generate_data_key_pair::GenerateDataKeyPairError::unhandled)?;
  121    103   
                let output = output.meta(generic);
  122    104   
                output.build()
  123    105   
            };
  124         -
            if tmp.message.is_none() {
  125         -
                tmp.message = _error_message;
  126         -
            }
  127    106   
            tmp
  128    107   
        }),
  129    108   
        "KMSInvalidStateException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::KmsInvalidStateException({
  130    109   
            #[allow(unused_mut)]
  131    110   
            let mut tmp = {
  132    111   
                #[allow(unused_mut)]
  133    112   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
  134    113   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
  135    114   
                    .map_err(crate::operation::generate_data_key_pair::GenerateDataKeyPairError::unhandled)?;
  136    115   
                let output = output.meta(generic);
  137    116   
                output.build()
  138    117   
            };
  139         -
            if tmp.message.is_none() {
  140         -
                tmp.message = _error_message;
  141         -
            }
  142    118   
            tmp
  143    119   
        }),
  144    120   
        "NotFoundException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::NotFoundException({
  145    121   
            #[allow(unused_mut)]
  146    122   
            let mut tmp = {
  147    123   
                #[allow(unused_mut)]
  148    124   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
  149    125   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
  150    126   
                    .map_err(crate::operation::generate_data_key_pair::GenerateDataKeyPairError::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   
        "UnsupportedOperationException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::UnsupportedOperationException({
  160    133   
            #[allow(unused_mut)]
  161    134   
            let mut tmp = {
  162    135   
                #[allow(unused_mut)]
  163    136   
                let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  164    137   
                output =
  165    138   
                    crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(_response_body, output)
  166    139   
                        .map_err(crate::operation::generate_data_key_pair::GenerateDataKeyPairError::unhandled)?;
  167    140   
                let output = output.meta(generic);
  168    141   
                output.build()
  169    142   
            };
  170         -
            if tmp.message.is_none() {
  171         -
                tmp.message = _error_message;
  172         -
            }
  173    143   
            tmp
  174    144   
        }),
  175    145   
        _ => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::generic(generic),
  176    146   
    })
  177    147   
}
  178    148   
  179    149   
#[allow(clippy::unnecessary_wraps)]
  180    150   
pub fn de_generate_data_key_pair_http_response(
  181    151   
    _response_status: u16,
  182    152   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +237,207 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::DependencyTimeoutExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_dependency_timeout_exception::de_dependency_timeout_exception_json_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::unhandled)?;
   34     34   
                    let output = output.meta(generic);
   35     35   
                    output.build()
   36     36   
                };
   37         -
                if tmp.message.is_none() {
   38         -
                    tmp.message = _error_message;
   39         -
                }
   40     37   
                tmp
   41     38   
            })
   42     39   
        }
   43     40   
        "DisabledException" => {
   44     41   
            crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::DisabledException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::DisabledExceptionBuilder::default();
   49     46   
                    output = crate::protocol_serde::shape_disabled_exception::de_disabled_exception_json_err(_response_body, output)
   50     47   
                        .map_err(crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::unhandled)?;
   51     48   
                    let output = output.meta(generic);
   52     49   
                    output.build()
   53     50   
                };
   54         -
                if tmp.message.is_none() {
   55         -
                    tmp.message = _error_message;
   56         -
                }
   57     51   
                tmp
   58     52   
            })
   59     53   
        }
   60     54   
        "DryRunOperationException" => {
   61     55   
            crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::DryRunOperationException({
   62     56   
                #[allow(unused_mut)]
   63     57   
                let mut tmp = {
   64     58   
                    #[allow(unused_mut)]
   65     59   
                    let mut output = crate::types::error::builders::DryRunOperationExceptionBuilder::default();
   66     60   
                    output =
   67     61   
                        crate::protocol_serde::shape_dry_run_operation_exception::de_dry_run_operation_exception_json_err(_response_body, output)
   68     62   
                            .map_err(
   69     63   
                                crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::unhandled,
   70     64   
                            )?;
   71     65   
                    let output = output.meta(generic);
   72     66   
                    output.build()
   73     67   
                };
   74         -
                if tmp.message.is_none() {
   75         -
                    tmp.message = _error_message;
   76         -
                }
   77     68   
                tmp
   78     69   
            })
   79     70   
        }
   80     71   
        "InvalidGrantTokenException" => {
   81     72   
            crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::InvalidGrantTokenException({
   82     73   
                #[allow(unused_mut)]
   83     74   
                let mut tmp = {
   84     75   
                    #[allow(unused_mut)]
   85     76   
                    let mut output = crate::types::error::builders::InvalidGrantTokenExceptionBuilder::default();
   86     77   
                    output =
   87     78   
                        crate::protocol_serde::shape_invalid_grant_token_exception::de_invalid_grant_token_exception_json_err(_response_body, output)
   88     79   
                            .map_err(
   89     80   
                                crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::unhandled,
   90     81   
                            )?;
   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   
        "InvalidKeyUsageException" => {
  101     89   
            crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::InvalidKeyUsageException({
  102     90   
                #[allow(unused_mut)]
  103     91   
                let mut tmp = {
  104     92   
                    #[allow(unused_mut)]
  105     93   
                    let mut output = crate::types::error::builders::InvalidKeyUsageExceptionBuilder::default();
  106     94   
                    output =
  107     95   
                        crate::protocol_serde::shape_invalid_key_usage_exception::de_invalid_key_usage_exception_json_err(_response_body, output)
  108     96   
                            .map_err(
  109     97   
                                crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::unhandled,
  110     98   
                            )?;
  111     99   
                    let output = output.meta(generic);
  112    100   
                    output.build()
  113    101   
                };
  114         -
                if tmp.message.is_none() {
  115         -
                    tmp.message = _error_message;
  116         -
                }
  117    102   
                tmp
  118    103   
            })
  119    104   
        }
  120    105   
        "KeyUnavailableException" => {
  121    106   
            crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::KeyUnavailableException({
  122    107   
                #[allow(unused_mut)]
  123    108   
                let mut tmp = {
  124    109   
                    #[allow(unused_mut)]
  125    110   
                    let mut output = crate::types::error::builders::KeyUnavailableExceptionBuilder::default();
  126    111   
                    output = crate::protocol_serde::shape_key_unavailable_exception::de_key_unavailable_exception_json_err(_response_body, output)
  127    112   
                        .map_err(crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::unhandled)?;
  128    113   
                    let output = output.meta(generic);
  129    114   
                    output.build()
  130    115   
                };
  131         -
                if tmp.message.is_none() {
  132         -
                    tmp.message = _error_message;
  133         -
                }
  134    116   
                tmp
  135    117   
            })
  136    118   
        }
  137    119   
        "KMSInternalException" => {
  138    120   
            crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::KmsInternalException({
  139    121   
                #[allow(unused_mut)]
  140    122   
                let mut tmp = {
  141    123   
                    #[allow(unused_mut)]
  142    124   
                    let mut output = crate::types::error::builders::KmsInternalExceptionBuilder::default();
  143    125   
                    output = crate::protocol_serde::shape_kms_internal_exception::de_kms_internal_exception_json_err(_response_body, output)
  144    126   
                        .map_err(crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::unhandled)?;
  145    127   
                    let output = output.meta(generic);
  146    128   
                    output.build()
  147    129   
                };
  148         -
                if tmp.message.is_none() {
  149         -
                    tmp.message = _error_message;
  150         -
                }
  151    130   
                tmp
  152    131   
            })
  153    132   
        }
  154    133   
        "KMSInvalidStateException" => {
  155    134   
            crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::KmsInvalidStateException({
  156    135   
                #[allow(unused_mut)]
  157    136   
                let mut tmp = {
  158    137   
                    #[allow(unused_mut)]
  159    138   
                    let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
  160    139   
                    output =
  161    140   
                        crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
  162    141   
                            .map_err(
  163    142   
                                crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::unhandled,
  164    143   
                            )?;
  165    144   
                    let output = output.meta(generic);
  166    145   
                    output.build()
  167    146   
                };
  168         -
                if tmp.message.is_none() {
  169         -
                    tmp.message = _error_message;
  170         -
                }
  171    147   
                tmp
  172    148   
            })
  173    149   
        }
  174    150   
        "NotFoundException" => {
  175    151   
            crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::NotFoundException({
  176    152   
                #[allow(unused_mut)]
  177    153   
                let mut tmp = {
  178    154   
                    #[allow(unused_mut)]
  179    155   
                    let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
  180    156   
                    output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
  181    157   
                        .map_err(crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::unhandled)?;
  182    158   
                    let output = output.meta(generic);
  183    159   
                    output.build()
  184    160   
                };
  185         -
                if tmp.message.is_none() {
  186         -
                    tmp.message = _error_message;
  187         -
                }
  188    161   
                tmp
  189    162   
            })
  190    163   
        }
  191    164   
        "UnsupportedOperationException" => {
  192    165   
            crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::UnsupportedOperationException({
  193    166   
                #[allow(unused_mut)]
  194    167   
                let mut tmp = {
  195    168   
                    #[allow(unused_mut)]
  196    169   
                    let mut output = crate::types::error::builders::UnsupportedOperationExceptionBuilder::default();
  197    170   
                    output = crate::protocol_serde::shape_unsupported_operation_exception::de_unsupported_operation_exception_json_err(
  198    171   
                        _response_body,
  199    172   
                        output,
  200    173   
                    )
  201    174   
                    .map_err(crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::unhandled)?;
  202    175   
                    let output = output.meta(generic);
  203    176   
                    output.build()
  204    177   
                };
  205         -
                if tmp.message.is_none() {
  206         -
                    tmp.message = _error_message;
  207         -
                }
  208    178   
                tmp
  209    179   
            })
  210    180   
        }
  211    181   
        _ => crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::generic(generic),
  212    182   
    })
  213    183   
}
  214    184   
  215    185   
#[allow(clippy::unnecessary_wraps)]
  216    186   
pub fn de_generate_data_key_pair_without_plaintext_http_response(
  217    187   
    _response_status: u16,

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

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

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

@@ -1,1 +168,144 @@
   20     20   
        "DisabledException" => crate::operation::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::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::generate_mac::GenerateMacError::generic(generic),
  142    118   
    })
  143    119   
}
  144    120   
  145    121   
#[allow(clippy::unnecessary_wraps)]
  146    122   
pub fn de_generate_mac_http_response(
  147    123   
    _response_status: u16,
  148    124   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,