AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_create_vault.rs

@@ -3,3 +107,95 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::create_vault::CreateVaultError::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   
        "LimitExceededException" => crate::operation::create_vault::CreateVaultError::LimitExceededException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::create_vault::CreateVaultError::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   
        "MissingParameterValueException" => crate::operation::create_vault::CreateVaultError::MissingParameterValueException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   59     53   
                    _response_body,
   60     54   
                    output,
   61     55   
                )
   62     56   
                .map_err(crate::operation::create_vault::CreateVaultError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "ServiceUnavailableException" => crate::operation::create_vault::CreateVaultError::ServiceUnavailableException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   76     67   
                output =
   77     68   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   78     69   
                        .map_err(crate::operation::create_vault::CreateVaultError::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   
        _ => crate::operation::create_vault::CreateVaultError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_create_vault_http_response(
   93     81   
    _response_status: u16,
   94     82   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_delete_archive.rs

@@ -3,3 +103,91 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::delete_archive::DeleteArchiveError::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   
        "MissingParameterValueException" => crate::operation::delete_archive::DeleteArchiveError::MissingParameterValueException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   44     41   
                    _response_body,
   45     42   
                    output,
   46     43   
                )
   47     44   
                .map_err(crate::operation::delete_archive::DeleteArchiveError::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   
        "ResourceNotFoundException" => crate::operation::delete_archive::DeleteArchiveError::ResourceNotFoundException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::delete_archive::DeleteArchiveError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "ServiceUnavailableException" => crate::operation::delete_archive::DeleteArchiveError::ServiceUnavailableException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   76     67   
                output =
   77     68   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   78     69   
                        .map_err(crate::operation::delete_archive::DeleteArchiveError::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   
        _ => crate::operation::delete_archive::DeleteArchiveError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_delete_archive_http_response(
   93     81   
    _response_status: u16,
   94     82   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_delete_vault.rs

@@ -3,3 +103,91 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::delete_vault::DeleteVaultError::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   
        "MissingParameterValueException" => crate::operation::delete_vault::DeleteVaultError::MissingParameterValueException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   44     41   
                    _response_body,
   45     42   
                    output,
   46     43   
                )
   47     44   
                .map_err(crate::operation::delete_vault::DeleteVaultError::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   
        "ResourceNotFoundException" => crate::operation::delete_vault::DeleteVaultError::ResourceNotFoundException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::delete_vault::DeleteVaultError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "ServiceUnavailableException" => crate::operation::delete_vault::DeleteVaultError::ServiceUnavailableException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   76     67   
                output =
   77     68   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   78     69   
                        .map_err(crate::operation::delete_vault::DeleteVaultError::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   
        _ => crate::operation::delete_vault::DeleteVaultError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_delete_vault_http_response(
   93     81   
    _response_status: u16,
   94     82   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_delete_vault_access_policy.rs

@@ -11,11 +117,105 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::delete_vault_access_policy::DeleteVaultAccessPolicyError::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   
        "MissingParameterValueException" => {
   48     45   
            crate::operation::delete_vault_access_policy::DeleteVaultAccessPolicyError::MissingParameterValueException({
   49     46   
                #[allow(unused_mut)]
   50     47   
                let mut tmp = {
   51     48   
                    #[allow(unused_mut)]
   52     49   
                    let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   53     50   
                    output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   54     51   
                        _response_body,
   55     52   
                        output,
   56     53   
                    )
   57     54   
                    .map_err(crate::operation::delete_vault_access_policy::DeleteVaultAccessPolicyError::unhandled)?;
   58     55   
                    let output = output.meta(generic);
   59     56   
                    output.build()
   60     57   
                };
   61         -
                if tmp.message.is_none() {
   62         -
                    tmp.message = _error_message;
   63         -
                }
   64     58   
                tmp
   65     59   
            })
   66     60   
        }
   67     61   
        "ResourceNotFoundException" => crate::operation::delete_vault_access_policy::DeleteVaultAccessPolicyError::ResourceNotFoundException({
   68     62   
            #[allow(unused_mut)]
   69     63   
            let mut tmp = {
   70     64   
                #[allow(unused_mut)]
   71     65   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   72     66   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   73     67   
                    .map_err(crate::operation::delete_vault_access_policy::DeleteVaultAccessPolicyError::unhandled)?;
   74     68   
                let output = output.meta(generic);
   75     69   
                output.build()
   76     70   
            };
   77         -
            if tmp.message.is_none() {
   78         -
                tmp.message = _error_message;
   79         -
            }
   80     71   
            tmp
   81     72   
        }),
   82     73   
        "ServiceUnavailableException" => crate::operation::delete_vault_access_policy::DeleteVaultAccessPolicyError::ServiceUnavailableException({
   83     74   
            #[allow(unused_mut)]
   84     75   
            let mut tmp = {
   85     76   
                #[allow(unused_mut)]
   86     77   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   87     78   
                output =
   88     79   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   89     80   
                        .map_err(crate::operation::delete_vault_access_policy::DeleteVaultAccessPolicyError::unhandled)?;
   90     81   
                let output = output.meta(generic);
   91     82   
                output.build()
   92     83   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     84   
            tmp
   97     85   
        }),
   98     86   
        _ => crate::operation::delete_vault_access_policy::DeleteVaultAccessPolicyError::generic(generic),
   99     87   
    })
  100     88   
}
  101     89   
  102     90   
#[allow(clippy::unnecessary_wraps)]
  103     91   
pub fn de_delete_vault_access_policy_http_response(
  104     92   
    _response_status: u16,
  105     93   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_delete_vault_notifications.rs

@@ -11,11 +117,105 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::delete_vault_notifications::DeleteVaultNotificationsError::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   
        "MissingParameterValueException" => {
   48     45   
            crate::operation::delete_vault_notifications::DeleteVaultNotificationsError::MissingParameterValueException({
   49     46   
                #[allow(unused_mut)]
   50     47   
                let mut tmp = {
   51     48   
                    #[allow(unused_mut)]
   52     49   
                    let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   53     50   
                    output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   54     51   
                        _response_body,
   55     52   
                        output,
   56     53   
                    )
   57     54   
                    .map_err(crate::operation::delete_vault_notifications::DeleteVaultNotificationsError::unhandled)?;
   58     55   
                    let output = output.meta(generic);
   59     56   
                    output.build()
   60     57   
                };
   61         -
                if tmp.message.is_none() {
   62         -
                    tmp.message = _error_message;
   63         -
                }
   64     58   
                tmp
   65     59   
            })
   66     60   
        }
   67     61   
        "ResourceNotFoundException" => crate::operation::delete_vault_notifications::DeleteVaultNotificationsError::ResourceNotFoundException({
   68     62   
            #[allow(unused_mut)]
   69     63   
            let mut tmp = {
   70     64   
                #[allow(unused_mut)]
   71     65   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   72     66   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   73     67   
                    .map_err(crate::operation::delete_vault_notifications::DeleteVaultNotificationsError::unhandled)?;
   74     68   
                let output = output.meta(generic);
   75     69   
                output.build()
   76     70   
            };
   77         -
            if tmp.message.is_none() {
   78         -
                tmp.message = _error_message;
   79         -
            }
   80     71   
            tmp
   81     72   
        }),
   82     73   
        "ServiceUnavailableException" => crate::operation::delete_vault_notifications::DeleteVaultNotificationsError::ServiceUnavailableException({
   83     74   
            #[allow(unused_mut)]
   84     75   
            let mut tmp = {
   85     76   
                #[allow(unused_mut)]
   86     77   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   87     78   
                output =
   88     79   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   89     80   
                        .map_err(crate::operation::delete_vault_notifications::DeleteVaultNotificationsError::unhandled)?;
   90     81   
                let output = output.meta(generic);
   91     82   
                output.build()
   92     83   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     84   
            tmp
   97     85   
        }),
   98     86   
        _ => crate::operation::delete_vault_notifications::DeleteVaultNotificationsError::generic(generic),
   99     87   
    })
  100     88   
}
  101     89   
  102     90   
#[allow(clippy::unnecessary_wraps)]
  103     91   
pub fn de_delete_vault_notifications_http_response(
  104     92   
    _response_status: u16,
  105     93   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_describe_job.rs

@@ -3,3 +114,102 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::describe_job::DescribeJobError::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   
        "MissingParameterValueException" => crate::operation::describe_job::DescribeJobError::MissingParameterValueException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   44     41   
                    _response_body,
   45     42   
                    output,
   46     43   
                )
   47     44   
                .map_err(crate::operation::describe_job::DescribeJobError::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   
        "ResourceNotFoundException" => crate::operation::describe_job::DescribeJobError::ResourceNotFoundException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::describe_job::DescribeJobError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "ServiceUnavailableException" => crate::operation::describe_job::DescribeJobError::ServiceUnavailableException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   76     67   
                output =
   77     68   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   78     69   
                        .map_err(crate::operation::describe_job::DescribeJobError::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   
        _ => crate::operation::describe_job::DescribeJobError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_describe_job_http_response(
   93     81   
    _response_status: u16,
   94     82   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_describe_vault.rs

@@ -3,3 +114,102 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::describe_vault::DescribeVaultError::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   
        "MissingParameterValueException" => crate::operation::describe_vault::DescribeVaultError::MissingParameterValueException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   44     41   
                    _response_body,
   45     42   
                    output,
   46     43   
                )
   47     44   
                .map_err(crate::operation::describe_vault::DescribeVaultError::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   
        "ResourceNotFoundException" => crate::operation::describe_vault::DescribeVaultError::ResourceNotFoundException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::describe_vault::DescribeVaultError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "ServiceUnavailableException" => crate::operation::describe_vault::DescribeVaultError::ServiceUnavailableException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   76     67   
                output =
   77     68   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   78     69   
                        .map_err(crate::operation::describe_vault::DescribeVaultError::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   
        _ => crate::operation::describe_vault::DescribeVaultError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_describe_vault_http_response(
   93     81   
    _response_status: u16,
   94     82   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_get_data_retrieval_policy.rs

@@ -11,11 +110,101 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::get_data_retrieval_policy::GetDataRetrievalPolicyError::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   
        "MissingParameterValueException" => {
   48     45   
            crate::operation::get_data_retrieval_policy::GetDataRetrievalPolicyError::MissingParameterValueException({
   49     46   
                #[allow(unused_mut)]
   50     47   
                let mut tmp = {
   51     48   
                    #[allow(unused_mut)]
   52     49   
                    let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   53     50   
                    output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   54     51   
                        _response_body,
   55     52   
                        output,
   56     53   
                    )
   57     54   
                    .map_err(crate::operation::get_data_retrieval_policy::GetDataRetrievalPolicyError::unhandled)?;
   58     55   
                    let output = output.meta(generic);
   59     56   
                    output.build()
   60     57   
                };
   61         -
                if tmp.message.is_none() {
   62         -
                    tmp.message = _error_message;
   63         -
                }
   64     58   
                tmp
   65     59   
            })
   66     60   
        }
   67     61   
        "ServiceUnavailableException" => crate::operation::get_data_retrieval_policy::GetDataRetrievalPolicyError::ServiceUnavailableException({
   68     62   
            #[allow(unused_mut)]
   69     63   
            let mut tmp = {
   70     64   
                #[allow(unused_mut)]
   71     65   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   72     66   
                output =
   73     67   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   74     68   
                        .map_err(crate::operation::get_data_retrieval_policy::GetDataRetrievalPolicyError::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::get_data_retrieval_policy::GetDataRetrievalPolicyError::generic(generic),
   84     75   
    })
   85     76   
}
   86     77   
   87     78   
#[allow(clippy::unnecessary_wraps)]
   88     79   
pub fn de_get_data_retrieval_policy_http_response(
   89     80   
    _response_status: u16,
   90     81   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_get_job_output.rs

@@ -50,50 +154,142 @@
   70     70   
                #[allow(unused_mut)]
   71     71   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   72     72   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   73     73   
                    _response_body,
   74     74   
                    output,
   75     75   
                )
   76     76   
                .map_err(crate::operation::get_job_output::GetJobOutputError::unhandled)?;
   77     77   
                let output = output.meta(generic);
   78     78   
                output.build()
   79     79   
            };
   80         -
            if tmp.message.is_none() {
   81         -
                tmp.message = _error_message;
   82         -
            }
   83     80   
            tmp
   84     81   
        }),
   85     82   
        "MissingParameterValueException" => crate::operation::get_job_output::GetJobOutputError::MissingParameterValueException({
   86     83   
            #[allow(unused_mut)]
   87     84   
            let mut tmp = {
   88     85   
                #[allow(unused_mut)]
   89     86   
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   90     87   
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   91     88   
                    _response_body,
   92     89   
                    output,
   93     90   
                )
   94     91   
                .map_err(crate::operation::get_job_output::GetJobOutputError::unhandled)?;
   95     92   
                let output = output.meta(generic);
   96     93   
                output.build()
   97     94   
            };
   98         -
            if tmp.message.is_none() {
   99         -
                tmp.message = _error_message;
  100         -
            }
  101     95   
            tmp
  102     96   
        }),
  103     97   
        "ResourceNotFoundException" => crate::operation::get_job_output::GetJobOutputError::ResourceNotFoundException({
  104     98   
            #[allow(unused_mut)]
  105     99   
            let mut tmp = {
  106    100   
                #[allow(unused_mut)]
  107    101   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
  108    102   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  109    103   
                    .map_err(crate::operation::get_job_output::GetJobOutputError::unhandled)?;
  110    104   
                let output = output.meta(generic);
  111    105   
                output.build()
  112    106   
            };
  113         -
            if tmp.message.is_none() {
  114         -
                tmp.message = _error_message;
  115         -
            }
  116    107   
            tmp
  117    108   
        }),
  118    109   
        "ServiceUnavailableException" => crate::operation::get_job_output::GetJobOutputError::ServiceUnavailableException({
  119    110   
            #[allow(unused_mut)]
  120    111   
            let mut tmp = {
  121    112   
                #[allow(unused_mut)]
  122    113   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
  123    114   
                output =
  124    115   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
  125    116   
                        .map_err(crate::operation::get_job_output::GetJobOutputError::unhandled)?;
  126    117   
                let output = output.meta(generic);
  127    118   
                output.build()
  128    119   
            };
  129         -
            if tmp.message.is_none() {
  130         -
                tmp.message = _error_message;
  131         -
            }
  132    120   
            tmp
  133    121   
        }),
  134    122   
        _ => crate::operation::get_job_output::GetJobOutputError::generic(generic),
  135    123   
    })
  136    124   
}
  137    125   
  138    126   
pub fn ser_get_job_output_headers(
  139    127   
    input: &crate::operation::get_job_output::GetJobOutputInput,
  140    128   
    mut builder: ::http::request::Builder,
  141    129   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_get_vault_access_policy.rs

@@ -6,6 +112,100 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::get_vault_access_policy::GetVaultAccessPolicyError::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   
        "MissingParameterValueException" => crate::operation::get_vault_access_policy::GetVaultAccessPolicyError::MissingParameterValueException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   47     44   
                    _response_body,
   48     45   
                    output,
   49     46   
                )
   50     47   
                .map_err(crate::operation::get_vault_access_policy::GetVaultAccessPolicyError::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   
        "ResourceNotFoundException" => crate::operation::get_vault_access_policy::GetVaultAccessPolicyError::ResourceNotFoundException({
   60     54   
            #[allow(unused_mut)]
   61     55   
            let mut tmp = {
   62     56   
                #[allow(unused_mut)]
   63     57   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   64     58   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   65     59   
                    .map_err(crate::operation::get_vault_access_policy::GetVaultAccessPolicyError::unhandled)?;
   66     60   
                let output = output.meta(generic);
   67     61   
                output.build()
   68     62   
            };
   69         -
            if tmp.message.is_none() {
   70         -
                tmp.message = _error_message;
   71         -
            }
   72     63   
            tmp
   73     64   
        }),
   74     65   
        "ServiceUnavailableException" => crate::operation::get_vault_access_policy::GetVaultAccessPolicyError::ServiceUnavailableException({
   75     66   
            #[allow(unused_mut)]
   76     67   
            let mut tmp = {
   77     68   
                #[allow(unused_mut)]
   78     69   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   79     70   
                output =
   80     71   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   81     72   
                        .map_err(crate::operation::get_vault_access_policy::GetVaultAccessPolicyError::unhandled)?;
   82     73   
                let output = output.meta(generic);
   83     74   
                output.build()
   84     75   
            };
   85         -
            if tmp.message.is_none() {
   86         -
                tmp.message = _error_message;
   87         -
            }
   88     76   
            tmp
   89     77   
        }),
   90     78   
        _ => crate::operation::get_vault_access_policy::GetVaultAccessPolicyError::generic(generic),
   91     79   
    })
   92     80   
}
   93     81   
   94     82   
#[allow(clippy::unnecessary_wraps)]
   95     83   
pub fn de_get_vault_access_policy_http_response(
   96     84   
    _response_status: u16,
   97     85   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_get_vault_lock.rs

@@ -3,3 +114,102 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::get_vault_lock::GetVaultLockError::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   
        "MissingParameterValueException" => crate::operation::get_vault_lock::GetVaultLockError::MissingParameterValueException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   44     41   
                    _response_body,
   45     42   
                    output,
   46     43   
                )
   47     44   
                .map_err(crate::operation::get_vault_lock::GetVaultLockError::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   
        "ResourceNotFoundException" => crate::operation::get_vault_lock::GetVaultLockError::ResourceNotFoundException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::get_vault_lock::GetVaultLockError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "ServiceUnavailableException" => crate::operation::get_vault_lock::GetVaultLockError::ServiceUnavailableException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   76     67   
                output =
   77     68   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   78     69   
                        .map_err(crate::operation::get_vault_lock::GetVaultLockError::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   
        _ => crate::operation::get_vault_lock::GetVaultLockError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_get_vault_lock_http_response(
   93     81   
    _response_status: u16,
   94     82   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_get_vault_notifications.rs

@@ -6,6 +112,100 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::get_vault_notifications::GetVaultNotificationsError::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   
        "MissingParameterValueException" => crate::operation::get_vault_notifications::GetVaultNotificationsError::MissingParameterValueException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   47     44   
                    _response_body,
   48     45   
                    output,
   49     46   
                )
   50     47   
                .map_err(crate::operation::get_vault_notifications::GetVaultNotificationsError::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   
        "ResourceNotFoundException" => crate::operation::get_vault_notifications::GetVaultNotificationsError::ResourceNotFoundException({
   60     54   
            #[allow(unused_mut)]
   61     55   
            let mut tmp = {
   62     56   
                #[allow(unused_mut)]
   63     57   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   64     58   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   65     59   
                    .map_err(crate::operation::get_vault_notifications::GetVaultNotificationsError::unhandled)?;
   66     60   
                let output = output.meta(generic);
   67     61   
                output.build()
   68     62   
            };
   69         -
            if tmp.message.is_none() {
   70         -
                tmp.message = _error_message;
   71         -
            }
   72     63   
            tmp
   73     64   
        }),
   74     65   
        "ServiceUnavailableException" => crate::operation::get_vault_notifications::GetVaultNotificationsError::ServiceUnavailableException({
   75     66   
            #[allow(unused_mut)]
   76     67   
            let mut tmp = {
   77     68   
                #[allow(unused_mut)]
   78     69   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   79     70   
                output =
   80     71   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   81     72   
                        .map_err(crate::operation::get_vault_notifications::GetVaultNotificationsError::unhandled)?;
   82     73   
                let output = output.meta(generic);
   83     74   
                output.build()
   84     75   
            };
   85         -
            if tmp.message.is_none() {
   86         -
                tmp.message = _error_message;
   87         -
            }
   88     76   
            tmp
   89     77   
        }),
   90     78   
        _ => crate::operation::get_vault_notifications::GetVaultNotificationsError::generic(generic),
   91     79   
    })
   92     80   
}
   93     81   
   94     82   
#[allow(clippy::unnecessary_wraps)]
   95     83   
pub fn de_get_vault_notifications_http_response(
   96     84   
    _response_status: u16,
   97     85   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_initiate_job.rs

@@ -1,1 +145,127 @@
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InsufficientCapacityExceptionBuilder::default();
   25     25   
                output =
   26     26   
                    crate::protocol_serde::shape_insufficient_capacity_exception::de_insufficient_capacity_exception_json_err(_response_body, output)
   27     27   
                        .map_err(crate::operation::initiate_job::InitiateJobError::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   
        "InvalidParameterValueException" => crate::operation::initiate_job::InitiateJobError::InvalidParameterValueException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   42     39   
                    _response_body,
   43     40   
                    output,
   44     41   
                )
   45     42   
                .map_err(crate::operation::initiate_job::InitiateJobError::unhandled)?;
   46     43   
                let output = output.meta(generic);
   47     44   
                output.build()
   48     45   
            };
   49         -
            if tmp.message.is_none() {
   50         -
                tmp.message = _error_message;
   51         -
            }
   52     46   
            tmp
   53     47   
        }),
   54     48   
        "MissingParameterValueException" => crate::operation::initiate_job::InitiateJobError::MissingParameterValueException({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   60     54   
                    _response_body,
   61     55   
                    output,
   62     56   
                )
   63     57   
                .map_err(crate::operation::initiate_job::InitiateJobError::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   
        "PolicyEnforcedException" => crate::operation::initiate_job::InitiateJobError::PolicyEnforcedException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::PolicyEnforcedExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_policy_enforced_exception::de_policy_enforced_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::initiate_job::InitiateJobError::unhandled)?;
   79     70   
                let output = output.meta(generic);
   80     71   
                output.build()
   81     72   
            };
   82         -
            if tmp.message.is_none() {
   83         -
                tmp.message = _error_message;
   84         -
            }
   85     73   
            tmp
   86     74   
        }),
   87     75   
        "ResourceNotFoundException" => crate::operation::initiate_job::InitiateJobError::ResourceNotFoundException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::initiate_job::InitiateJobError::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   
        "ServiceUnavailableException" => crate::operation::initiate_job::InitiateJobError::ServiceUnavailableException({
  103     88   
            #[allow(unused_mut)]
  104     89   
            let mut tmp = {
  105     90   
                #[allow(unused_mut)]
  106     91   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
  107     92   
                output =
  108     93   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
  109     94   
                        .map_err(crate::operation::initiate_job::InitiateJobError::unhandled)?;
  110     95   
                let output = output.meta(generic);
  111     96   
                output.build()
  112     97   
            };
  113         -
            if tmp.message.is_none() {
  114         -
                tmp.message = _error_message;
  115         -
            }
  116     98   
            tmp
  117     99   
        }),
  118    100   
        _ => crate::operation::initiate_job::InitiateJobError::generic(generic),
  119    101   
    })
  120    102   
}
  121    103   
  122    104   
#[allow(clippy::unnecessary_wraps)]
  123    105   
pub fn de_initiate_job_http_response(
  124    106   
    _response_status: u16,
  125    107   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_initiate_multipart_upload.rs

@@ -11,11 +125,113 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::initiate_multipart_upload::InitiateMultipartUploadError::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   
        "MissingParameterValueException" => {
   48     45   
            crate::operation::initiate_multipart_upload::InitiateMultipartUploadError::MissingParameterValueException({
   49     46   
                #[allow(unused_mut)]
   50     47   
                let mut tmp = {
   51     48   
                    #[allow(unused_mut)]
   52     49   
                    let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   53     50   
                    output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   54     51   
                        _response_body,
   55     52   
                        output,
   56     53   
                    )
   57     54   
                    .map_err(crate::operation::initiate_multipart_upload::InitiateMultipartUploadError::unhandled)?;
   58     55   
                    let output = output.meta(generic);
   59     56   
                    output.build()
   60     57   
                };
   61         -
                if tmp.message.is_none() {
   62         -
                    tmp.message = _error_message;
   63         -
                }
   64     58   
                tmp
   65     59   
            })
   66     60   
        }
   67     61   
        "ResourceNotFoundException" => crate::operation::initiate_multipart_upload::InitiateMultipartUploadError::ResourceNotFoundException({
   68     62   
            #[allow(unused_mut)]
   69     63   
            let mut tmp = {
   70     64   
                #[allow(unused_mut)]
   71     65   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   72     66   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   73     67   
                    .map_err(crate::operation::initiate_multipart_upload::InitiateMultipartUploadError::unhandled)?;
   74     68   
                let output = output.meta(generic);
   75     69   
                output.build()
   76     70   
            };
   77         -
            if tmp.message.is_none() {
   78         -
                tmp.message = _error_message;
   79         -
            }
   80     71   
            tmp
   81     72   
        }),
   82     73   
        "ServiceUnavailableException" => crate::operation::initiate_multipart_upload::InitiateMultipartUploadError::ServiceUnavailableException({
   83     74   
            #[allow(unused_mut)]
   84     75   
            let mut tmp = {
   85     76   
                #[allow(unused_mut)]
   86     77   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   87     78   
                output =
   88     79   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   89     80   
                        .map_err(crate::operation::initiate_multipart_upload::InitiateMultipartUploadError::unhandled)?;
   90     81   
                let output = output.meta(generic);
   91     82   
                output.build()
   92     83   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     84   
            tmp
   97     85   
        }),
   98     86   
        _ => crate::operation::initiate_multipart_upload::InitiateMultipartUploadError::generic(generic),
   99     87   
    })
  100     88   
}
  101     89   
  102     90   
#[allow(clippy::unnecessary_wraps)]
  103     91   
pub fn de_initiate_multipart_upload_http_response(
  104     92   
    _response_status: u16,
  105     93   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_initiate_vault_lock.rs

@@ -4,4 +110,98 @@
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   27     27   
                    _response_body,
   28     28   
                    output,
   29     29   
                )
   30     30   
                .map_err(crate::operation::initiate_vault_lock::InitiateVaultLockError::unhandled)?;
   31     31   
                let output = output.meta(generic);
   32     32   
                output.build()
   33     33   
            };
   34         -
            if tmp.message.is_none() {
   35         -
                tmp.message = _error_message;
   36         -
            }
   37     34   
            tmp
   38     35   
        }),
   39     36   
        "MissingParameterValueException" => crate::operation::initiate_vault_lock::InitiateVaultLockError::MissingParameterValueException({
   40     37   
            #[allow(unused_mut)]
   41     38   
            let mut tmp = {
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   44     41   
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   45     42   
                    _response_body,
   46     43   
                    output,
   47     44   
                )
   48     45   
                .map_err(crate::operation::initiate_vault_lock::InitiateVaultLockError::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   
        "ResourceNotFoundException" => crate::operation::initiate_vault_lock::InitiateVaultLockError::ResourceNotFoundException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::initiate_vault_lock::InitiateVaultLockError::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   
        "ServiceUnavailableException" => crate::operation::initiate_vault_lock::InitiateVaultLockError::ServiceUnavailableException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   77     68   
                output =
   78     69   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   79     70   
                        .map_err(crate::operation::initiate_vault_lock::InitiateVaultLockError::unhandled)?;
   80     71   
                let output = output.meta(generic);
   81     72   
                output.build()
   82     73   
            };
   83         -
            if tmp.message.is_none() {
   84         -
                tmp.message = _error_message;
   85         -
            }
   86     74   
            tmp
   87     75   
        }),
   88     76   
        _ => crate::operation::initiate_vault_lock::InitiateVaultLockError::generic(generic),
   89     77   
    })
   90     78   
}
   91     79   
   92     80   
#[allow(clippy::unnecessary_wraps)]
   93     81   
pub fn de_initiate_vault_lock_http_response(
   94     82   
    _response_status: u16,
   95     83   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_list_jobs.rs

@@ -3,3 +114,102 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::list_jobs::ListJobsError::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   
        "MissingParameterValueException" => crate::operation::list_jobs::ListJobsError::MissingParameterValueException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   44     41   
                    _response_body,
   45     42   
                    output,
   46     43   
                )
   47     44   
                .map_err(crate::operation::list_jobs::ListJobsError::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   
        "ResourceNotFoundException" => crate::operation::list_jobs::ListJobsError::ResourceNotFoundException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::list_jobs::ListJobsError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "ServiceUnavailableException" => crate::operation::list_jobs::ListJobsError::ServiceUnavailableException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   76     67   
                output =
   77     68   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   78     69   
                        .map_err(crate::operation::list_jobs::ListJobsError::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   
        _ => crate::operation::list_jobs::ListJobsError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_list_jobs_http_response(
   93     81   
    _response_status: u16,
   94     82   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,