AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05 (ignoring whitespace)

Files changed:

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

@@ -1,1 +121,106 @@
   20     20   
        "ClientException" => crate::operation::tag_resource::TagResourceError::ClientException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ClientExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_client_exception::de_client_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::tag_resource::TagResourceError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "ClusterNotFoundException" => crate::operation::tag_resource::TagResourceError::ClusterNotFoundException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ClusterNotFoundExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_cluster_not_found_exception::de_cluster_not_found_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::tag_resource::TagResourceError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "InvalidParameterException" => crate::operation::tag_resource::TagResourceError::InvalidParameterException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::tag_resource::TagResourceError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "ResourceNotFoundException" => crate::operation::tag_resource::TagResourceError::ResourceNotFoundException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::tag_resource::TagResourceError::unhandled)?;
   72     63   
                let output = output.meta(generic);
   73     64   
                output.build()
   74     65   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     66   
            tmp
   79     67   
        }),
   80     68   
        "ServerException" => crate::operation::tag_resource::TagResourceError::ServerException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::tag_resource::TagResourceError::unhandled)?;
   87     75   
                let output = output.meta(generic);
   88     76   
                output.build()
   89     77   
            };
   90         -
            if tmp.message.is_none() {
   91         -
                tmp.message = _error_message;
   92         -
            }
   93     78   
            tmp
   94     79   
        }),
   95     80   
        _ => crate::operation::tag_resource::TagResourceError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_tag_resource_http_response(
  101     86   
    _response_status: u16,
  102     87   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +121,106 @@
   20     20   
        "ClientException" => crate::operation::untag_resource::UntagResourceError::ClientException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ClientExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_client_exception::de_client_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::untag_resource::UntagResourceError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "ClusterNotFoundException" => crate::operation::untag_resource::UntagResourceError::ClusterNotFoundException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ClusterNotFoundExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_cluster_not_found_exception::de_cluster_not_found_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::untag_resource::UntagResourceError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "InvalidParameterException" => crate::operation::untag_resource::UntagResourceError::InvalidParameterException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::untag_resource::UntagResourceError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "ResourceNotFoundException" => crate::operation::untag_resource::UntagResourceError::ResourceNotFoundException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::untag_resource::UntagResourceError::unhandled)?;
   72     63   
                let output = output.meta(generic);
   73     64   
                output.build()
   74     65   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     66   
            tmp
   79     67   
        }),
   80     68   
        "ServerException" => crate::operation::untag_resource::UntagResourceError::ServerException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::untag_resource::UntagResourceError::unhandled)?;
   87     75   
                let output = output.meta(generic);
   88     76   
                output.build()
   89     77   
            };
   90         -
            if tmp.message.is_none() {
   91         -
                tmp.message = _error_message;
   92         -
            }
   93     78   
            tmp
   94     79   
        }),
   95     80   
        _ => crate::operation::untag_resource::UntagResourceError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_untag_resource_http_response(
  101     86   
    _response_status: u16,
  102     87   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/ecs/src/protocol_serde/shape_update_capacity_provider.rs

@@ -7,7 +99,90 @@
   27     27   
        "ClientException" => crate::operation::update_capacity_provider::UpdateCapacityProviderError::ClientException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::ClientExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_client_exception::de_client_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::update_capacity_provider::UpdateCapacityProviderError::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   
        "InvalidParameterException" => crate::operation::update_capacity_provider::UpdateCapacityProviderError::InvalidParameterException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::update_capacity_provider::UpdateCapacityProviderError::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   
        "ServerException" => crate::operation::update_capacity_provider::UpdateCapacityProviderError::ServerException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::update_capacity_provider::UpdateCapacityProviderError::unhandled)?;
   64     58   
                let output = output.meta(generic);
   65     59   
                output.build()
   66     60   
            };
   67         -
            if tmp.message.is_none() {
   68         -
                tmp.message = _error_message;
   69         -
            }
   70     61   
            tmp
   71     62   
        }),
   72     63   
        _ => crate::operation::update_capacity_provider::UpdateCapacityProviderError::generic(generic),
   73     64   
    })
   74     65   
}
   75     66   
   76     67   
#[allow(clippy::unnecessary_wraps)]
   77     68   
pub fn de_update_capacity_provider_http_response(
   78     69   
    _response_status: u16,
   79     70   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/ecs/src/protocol_serde/shape_update_cluster.rs

@@ -1,1 +123,108 @@
   20     20   
        "ClientException" => crate::operation::update_cluster::UpdateClusterError::ClientException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ClientExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_client_exception::de_client_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::update_cluster::UpdateClusterError::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   
        "ClusterNotFoundException" => crate::operation::update_cluster::UpdateClusterError::ClusterNotFoundException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ClusterNotFoundExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_cluster_not_found_exception::de_cluster_not_found_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::update_cluster::UpdateClusterError::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   
        "InvalidParameterException" => crate::operation::update_cluster::UpdateClusterError::InvalidParameterException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::update_cluster::UpdateClusterError::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   
        "NamespaceNotFoundException" => crate::operation::update_cluster::UpdateClusterError::NamespaceNotFoundException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::NamespaceNotFoundExceptionBuilder::default();
   70     61   
                output =
   71     62   
                    crate::protocol_serde::shape_namespace_not_found_exception::de_namespace_not_found_exception_json_err(_response_body, output)
   72     63   
                        .map_err(crate::operation::update_cluster::UpdateClusterError::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   
        "ServerException" => crate::operation::update_cluster::UpdateClusterError::ServerException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   87     75   
                    .map_err(crate::operation::update_cluster::UpdateClusterError::unhandled)?;
   88     76   
                let output = output.meta(generic);
   89     77   
                output.build()
   90     78   
            };
   91         -
            if tmp.message.is_none() {
   92         -
                tmp.message = _error_message;
   93         -
            }
   94     79   
            tmp
   95     80   
        }),
   96     81   
        _ => crate::operation::update_cluster::UpdateClusterError::generic(generic),
   97     82   
    })
   98     83   
}
   99     84   
  100     85   
#[allow(clippy::unnecessary_wraps)]
  101     86   
pub fn de_update_cluster_http_response(
  102     87   
    _response_status: u16,
  103     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/ecs/src/protocol_serde/shape_update_cluster_settings.rs

@@ -3,3 +110,98 @@
   23     23   
        "ClientException" => crate::operation::update_cluster_settings::UpdateClusterSettingsError::ClientException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ClientExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_client_exception::de_client_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::update_cluster_settings::UpdateClusterSettingsError::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   
        "ClusterNotFoundException" => crate::operation::update_cluster_settings::UpdateClusterSettingsError::ClusterNotFoundException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ClusterNotFoundExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_cluster_not_found_exception::de_cluster_not_found_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::update_cluster_settings::UpdateClusterSettingsError::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   
        "InvalidParameterException" => crate::operation::update_cluster_settings::UpdateClusterSettingsError::InvalidParameterException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::update_cluster_settings::UpdateClusterSettingsError::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   
        "ServerException" => crate::operation::update_cluster_settings::UpdateClusterSettingsError::ServerException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::update_cluster_settings::UpdateClusterSettingsError::unhandled)?;
   75     66   
                let output = output.meta(generic);
   76     67   
                output.build()
   77     68   
            };
   78         -
            if tmp.message.is_none() {
   79         -
                tmp.message = _error_message;
   80         -
            }
   81     69   
            tmp
   82     70   
        }),
   83     71   
        _ => crate::operation::update_cluster_settings::UpdateClusterSettingsError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_update_cluster_settings_http_response(
   89     77   
    _response_status: u16,
   90     78   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/ecs/src/protocol_serde/shape_update_container_agent.rs

@@ -3,3 +156,135 @@
   23     23   
        "ClientException" => crate::operation::update_container_agent::UpdateContainerAgentError::ClientException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ClientExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_client_exception::de_client_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::update_container_agent::UpdateContainerAgentError::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   
        "ClusterNotFoundException" => crate::operation::update_container_agent::UpdateContainerAgentError::ClusterNotFoundException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ClusterNotFoundExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_cluster_not_found_exception::de_cluster_not_found_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::update_container_agent::UpdateContainerAgentError::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   
        "InvalidParameterException" => crate::operation::update_container_agent::UpdateContainerAgentError::InvalidParameterException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::update_container_agent::UpdateContainerAgentError::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   
        "MissingVersionException" => crate::operation::update_container_agent::UpdateContainerAgentError::MissingVersionException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::MissingVersionExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_missing_version_exception::de_missing_version_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::update_container_agent::UpdateContainerAgentError::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   
        "NoUpdateAvailableException" => crate::operation::update_container_agent::UpdateContainerAgentError::NoUpdateAvailableException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::NoUpdateAvailableExceptionBuilder::default();
   88     76   
                output =
   89     77   
                    crate::protocol_serde::shape_no_update_available_exception::de_no_update_available_exception_json_err(_response_body, output)
   90     78   
                        .map_err(crate::operation::update_container_agent::UpdateContainerAgentError::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   
        "ServerException" => crate::operation::update_container_agent::UpdateContainerAgentError::ServerException({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
  105     90   
                    .map_err(crate::operation::update_container_agent::UpdateContainerAgentError::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   
        "UpdateInProgressException" => crate::operation::update_container_agent::UpdateContainerAgentError::UpdateInProgressException({
  115     97   
            #[allow(unused_mut)]
  116     98   
            let mut tmp = {
  117     99   
                #[allow(unused_mut)]
  118    100   
                let mut output = crate::types::error::builders::UpdateInProgressExceptionBuilder::default();
  119    101   
                output = crate::protocol_serde::shape_update_in_progress_exception::de_update_in_progress_exception_json_err(_response_body, output)
  120    102   
                    .map_err(crate::operation::update_container_agent::UpdateContainerAgentError::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::update_container_agent::UpdateContainerAgentError::generic(generic),
  130    109   
    })
  131    110   
}
  132    111   
  133    112   
#[allow(clippy::unnecessary_wraps)]
  134    113   
pub fn de_update_container_agent_http_response(
  135    114   
    _response_status: u16,
  136    115   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/ecs/src/protocol_serde/shape_update_container_instances_state.rs

@@ -3,3 +116,104 @@
   23     23   
        "ClientException" => crate::operation::update_container_instances_state::UpdateContainerInstancesStateError::ClientException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ClientExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_client_exception::de_client_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::update_container_instances_state::UpdateContainerInstancesStateError::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   
        "ClusterNotFoundException" => {
   39     36   
            crate::operation::update_container_instances_state::UpdateContainerInstancesStateError::ClusterNotFoundException({
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut tmp = {
   42     39   
                    #[allow(unused_mut)]
   43     40   
                    let mut output = crate::types::error::builders::ClusterNotFoundExceptionBuilder::default();
   44     41   
                    output =
   45     42   
                        crate::protocol_serde::shape_cluster_not_found_exception::de_cluster_not_found_exception_json_err(_response_body, output)
   46     43   
                            .map_err(crate::operation::update_container_instances_state::UpdateContainerInstancesStateError::unhandled)?;
   47     44   
                    let output = output.meta(generic);
   48     45   
                    output.build()
   49     46   
                };
   50         -
                if tmp.message.is_none() {
   51         -
                    tmp.message = _error_message;
   52         -
                }
   53     47   
                tmp
   54     48   
            })
   55     49   
        }
   56     50   
        "InvalidParameterException" => {
   57     51   
            crate::operation::update_container_instances_state::UpdateContainerInstancesStateError::InvalidParameterException({
   58     52   
                #[allow(unused_mut)]
   59     53   
                let mut tmp = {
   60     54   
                    #[allow(unused_mut)]
   61     55   
                    let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   62     56   
                    output =
   63     57   
                        crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   64     58   
                            .map_err(crate::operation::update_container_instances_state::UpdateContainerInstancesStateError::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   
        "ServerException" => crate::operation::update_container_instances_state::UpdateContainerInstancesStateError::ServerException({
   75     66   
            #[allow(unused_mut)]
   76     67   
            let mut tmp = {
   77     68   
                #[allow(unused_mut)]
   78     69   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   79     70   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   80     71   
                    .map_err(crate::operation::update_container_instances_state::UpdateContainerInstancesStateError::unhandled)?;
   81     72   
                let output = output.meta(generic);
   82     73   
                output.build()
   83     74   
            };
   84         -
            if tmp.message.is_none() {
   85         -
                tmp.message = _error_message;
   86         -
            }
   87     75   
            tmp
   88     76   
        }),
   89     77   
        _ => crate::operation::update_container_instances_state::UpdateContainerInstancesStateError::generic(generic),
   90     78   
    })
   91     79   
}
   92     80   
   93     81   
#[allow(clippy::unnecessary_wraps)]
   94     82   
pub fn de_update_container_instances_state_http_response(
   95     83   
    _response_status: u16,
   96     84   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/ecs/src/protocol_serde/shape_update_service.rs

@@ -1,1 +215,182 @@
   20     20   
        "AccessDeniedException" => crate::operation::update_service::UpdateServiceError::AccessDeniedException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::update_service::UpdateServiceError::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   
        "ClientException" => crate::operation::update_service::UpdateServiceError::ClientException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ClientExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_client_exception::de_client_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::update_service::UpdateServiceError::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   
        "ClusterNotFoundException" => crate::operation::update_service::UpdateServiceError::ClusterNotFoundException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ClusterNotFoundExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_cluster_not_found_exception::de_cluster_not_found_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::update_service::UpdateServiceError::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   
        "InvalidParameterException" => crate::operation::update_service::UpdateServiceError::InvalidParameterException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::update_service::UpdateServiceError::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   
        "NamespaceNotFoundException" => crate::operation::update_service::UpdateServiceError::NamespaceNotFoundException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::NamespaceNotFoundExceptionBuilder::default();
   85     73   
                output =
   86     74   
                    crate::protocol_serde::shape_namespace_not_found_exception::de_namespace_not_found_exception_json_err(_response_body, output)
   87     75   
                        .map_err(crate::operation::update_service::UpdateServiceError::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   
        "PlatformTaskDefinitionIncompatibilityException" => {
   97     82   
            crate::operation::update_service::UpdateServiceError::PlatformTaskDefinitionIncompatibilityException({
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut tmp = {
  100     85   
                    #[allow(unused_mut)]
  101     86   
                    let mut output = crate::types::error::builders::PlatformTaskDefinitionIncompatibilityExceptionBuilder::default();
  102     87   
                    output = crate::protocol_serde::shape_platform_task_definition_incompatibility_exception::de_platform_task_definition_incompatibility_exception_json_err(_response_body, output).map_err(crate::operation::update_service::UpdateServiceError::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   
        }
  112     94   
        "PlatformUnknownException" => crate::operation::update_service::UpdateServiceError::PlatformUnknownException({
  113     95   
            #[allow(unused_mut)]
  114     96   
            let mut tmp = {
  115     97   
                #[allow(unused_mut)]
  116     98   
                let mut output = crate::types::error::builders::PlatformUnknownExceptionBuilder::default();
  117     99   
                output = crate::protocol_serde::shape_platform_unknown_exception::de_platform_unknown_exception_json_err(_response_body, output)
  118    100   
                    .map_err(crate::operation::update_service::UpdateServiceError::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   
        "ServerException" => crate::operation::update_service::UpdateServiceError::ServerException({
  128    107   
            #[allow(unused_mut)]
  129    108   
            let mut tmp = {
  130    109   
                #[allow(unused_mut)]
  131    110   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
  132    111   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
  133    112   
                    .map_err(crate::operation::update_service::UpdateServiceError::unhandled)?;
  134    113   
                let output = output.meta(generic);
  135    114   
                output.build()
  136    115   
            };
  137         -
            if tmp.message.is_none() {
  138         -
                tmp.message = _error_message;
  139         -
            }
  140    116   
            tmp
  141    117   
        }),
  142    118   
        "ServiceNotActiveException" => crate::operation::update_service::UpdateServiceError::ServiceNotActiveException({
  143    119   
            #[allow(unused_mut)]
  144    120   
            let mut tmp = {
  145    121   
                #[allow(unused_mut)]
  146    122   
                let mut output = crate::types::error::builders::ServiceNotActiveExceptionBuilder::default();
  147    123   
                output = crate::protocol_serde::shape_service_not_active_exception::de_service_not_active_exception_json_err(_response_body, output)
  148    124   
                    .map_err(crate::operation::update_service::UpdateServiceError::unhandled)?;
  149    125   
                let output = output.meta(generic);
  150    126   
                output.build()
  151    127   
            };
  152         -
            if tmp.message.is_none() {
  153         -
                tmp.message = _error_message;
  154         -
            }
  155    128   
            tmp
  156    129   
        }),
  157    130   
        "ServiceNotFoundException" => crate::operation::update_service::UpdateServiceError::ServiceNotFoundException({
  158    131   
            #[allow(unused_mut)]
  159    132   
            let mut tmp = {
  160    133   
                #[allow(unused_mut)]
  161    134   
                let mut output = crate::types::error::builders::ServiceNotFoundExceptionBuilder::default();
  162    135   
                output = crate::protocol_serde::shape_service_not_found_exception::de_service_not_found_exception_json_err(_response_body, output)
  163    136   
                    .map_err(crate::operation::update_service::UpdateServiceError::unhandled)?;
  164    137   
                let output = output.meta(generic);
  165    138   
                output.build()
  166    139   
            };
  167         -
            if tmp.message.is_none() {
  168         -
                tmp.message = _error_message;
  169         -
            }
  170    140   
            tmp
  171    141   
        }),
  172    142   
        "UnsupportedFeatureException" => crate::operation::update_service::UpdateServiceError::UnsupportedFeatureException({
  173    143   
            #[allow(unused_mut)]
  174    144   
            let mut tmp = {
  175    145   
                #[allow(unused_mut)]
  176    146   
                let mut output = crate::types::error::builders::UnsupportedFeatureExceptionBuilder::default();
  177    147   
                output =
  178    148   
                    crate::protocol_serde::shape_unsupported_feature_exception::de_unsupported_feature_exception_json_err(_response_body, output)
  179    149   
                        .map_err(crate::operation::update_service::UpdateServiceError::unhandled)?;
  180    150   
                let output = output.meta(generic);
  181    151   
                output.build()
  182    152   
            };
  183         -
            if tmp.message.is_none() {
  184         -
                tmp.message = _error_message;
  185         -
            }
  186    153   
            tmp
  187    154   
        }),
  188    155   
        _ => crate::operation::update_service::UpdateServiceError::generic(generic),
  189    156   
    })
  190    157   
}
  191    158   
  192    159   
#[allow(clippy::unnecessary_wraps)]
  193    160   
pub fn de_update_service_http_response(
  194    161   
    _response_status: u16,
  195    162   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/ecs/src/protocol_serde/shape_update_service_primary_task_set.rs

@@ -3,3 +202,175 @@
   23     23   
        "AccessDeniedException" => crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::AccessDeniedException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::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   
        "ClientException" => crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::ClientException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ClientExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_client_exception::de_client_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::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   
        "ClusterNotFoundException" => {
   54     48   
            crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::ClusterNotFoundException({
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut tmp = {
   57     51   
                    #[allow(unused_mut)]
   58     52   
                    let mut output = crate::types::error::builders::ClusterNotFoundExceptionBuilder::default();
   59     53   
                    output =
   60     54   
                        crate::protocol_serde::shape_cluster_not_found_exception::de_cluster_not_found_exception_json_err(_response_body, output)
   61     55   
                            .map_err(crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::unhandled)?;
   62     56   
                    let output = output.meta(generic);
   63     57   
                    output.build()
   64     58   
                };
   65         -
                if tmp.message.is_none() {
   66         -
                    tmp.message = _error_message;
   67         -
                }
   68     59   
                tmp
   69     60   
            })
   70     61   
        }
   71     62   
        "InvalidParameterException" => {
   72     63   
            crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::InvalidParameterException({
   73     64   
                #[allow(unused_mut)]
   74     65   
                let mut tmp = {
   75     66   
                    #[allow(unused_mut)]
   76     67   
                    let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   77     68   
                    output =
   78     69   
                        crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   79     70   
                            .map_err(crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::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   
        }
   89     77   
        "ServerException" => crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::ServerException({
   90     78   
            #[allow(unused_mut)]
   91     79   
            let mut tmp = {
   92     80   
                #[allow(unused_mut)]
   93     81   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   94     82   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   95     83   
                    .map_err(crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::unhandled)?;
   96     84   
                let output = output.meta(generic);
   97     85   
                output.build()
   98     86   
            };
   99         -
            if tmp.message.is_none() {
  100         -
                tmp.message = _error_message;
  101         -
            }
  102     87   
            tmp
  103     88   
        }),
  104     89   
        "ServiceNotActiveException" => {
  105     90   
            crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::ServiceNotActiveException({
  106     91   
                #[allow(unused_mut)]
  107     92   
                let mut tmp = {
  108     93   
                    #[allow(unused_mut)]
  109     94   
                    let mut output = crate::types::error::builders::ServiceNotActiveExceptionBuilder::default();
  110     95   
                    output =
  111     96   
                        crate::protocol_serde::shape_service_not_active_exception::de_service_not_active_exception_json_err(_response_body, output)
  112     97   
                            .map_err(crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::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   
        "ServiceNotFoundException" => {
  123    105   
            crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::ServiceNotFoundException({
  124    106   
                #[allow(unused_mut)]
  125    107   
                let mut tmp = {
  126    108   
                    #[allow(unused_mut)]
  127    109   
                    let mut output = crate::types::error::builders::ServiceNotFoundExceptionBuilder::default();
  128    110   
                    output =
  129    111   
                        crate::protocol_serde::shape_service_not_found_exception::de_service_not_found_exception_json_err(_response_body, output)
  130    112   
                            .map_err(crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::unhandled)?;
  131    113   
                    let output = output.meta(generic);
  132    114   
                    output.build()
  133    115   
                };
  134         -
                if tmp.message.is_none() {
  135         -
                    tmp.message = _error_message;
  136         -
                }
  137    116   
                tmp
  138    117   
            })
  139    118   
        }
  140    119   
        "TaskSetNotFoundException" => {
  141    120   
            crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::TaskSetNotFoundException({
  142    121   
                #[allow(unused_mut)]
  143    122   
                let mut tmp = {
  144    123   
                    #[allow(unused_mut)]
  145    124   
                    let mut output = crate::types::error::builders::TaskSetNotFoundExceptionBuilder::default();
  146    125   
                    output =
  147    126   
                        crate::protocol_serde::shape_task_set_not_found_exception::de_task_set_not_found_exception_json_err(_response_body, output)
  148    127   
                            .map_err(crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::unhandled)?;
  149    128   
                    let output = output.meta(generic);
  150    129   
                    output.build()
  151    130   
                };
  152         -
                if tmp.message.is_none() {
  153         -
                    tmp.message = _error_message;
  154         -
                }
  155    131   
                tmp
  156    132   
            })
  157    133   
        }
  158    134   
        "UnsupportedFeatureException" => {
  159    135   
            crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::UnsupportedFeatureException({
  160    136   
                #[allow(unused_mut)]
  161    137   
                let mut tmp = {
  162    138   
                    #[allow(unused_mut)]
  163    139   
                    let mut output = crate::types::error::builders::UnsupportedFeatureExceptionBuilder::default();
  164    140   
                    output =
  165    141   
                        crate::protocol_serde::shape_unsupported_feature_exception::de_unsupported_feature_exception_json_err(_response_body, output)
  166    142   
                            .map_err(crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::unhandled)?;
  167    143   
                    let output = output.meta(generic);
  168    144   
                    output.build()
  169    145   
                };
  170         -
                if tmp.message.is_none() {
  171         -
                    tmp.message = _error_message;
  172         -
                }
  173    146   
                tmp
  174    147   
            })
  175    148   
        }
  176    149   
        _ => crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetError::generic(generic),
  177    150   
    })
  178    151   
}
  179    152   
  180    153   
#[allow(clippy::unnecessary_wraps)]
  181    154   
pub fn de_update_service_primary_task_set_http_response(
  182    155   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/ecs/src/protocol_serde/shape_update_task_protection.rs

@@ -3,3 +156,135 @@
   23     23   
        "AccessDeniedException" => crate::operation::update_task_protection::UpdateTaskProtectionError::AccessDeniedException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::update_task_protection::UpdateTaskProtectionError::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   
        "ClientException" => crate::operation::update_task_protection::UpdateTaskProtectionError::ClientException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ClientExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_client_exception::de_client_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::update_task_protection::UpdateTaskProtectionError::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   
        "ClusterNotFoundException" => crate::operation::update_task_protection::UpdateTaskProtectionError::ClusterNotFoundException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ClusterNotFoundExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_cluster_not_found_exception::de_cluster_not_found_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::update_task_protection::UpdateTaskProtectionError::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   
        "InvalidParameterException" => crate::operation::update_task_protection::UpdateTaskProtectionError::InvalidParameterException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::update_task_protection::UpdateTaskProtectionError::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   
        "ResourceNotFoundException" => crate::operation::update_task_protection::UpdateTaskProtectionError::ResourceNotFoundException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::update_task_protection::UpdateTaskProtectionError::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   
        "ServerException" => crate::operation::update_task_protection::UpdateTaskProtectionError::ServerException({
   99     84   
            #[allow(unused_mut)]
  100     85   
            let mut tmp = {
  101     86   
                #[allow(unused_mut)]
  102     87   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
  103     88   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
  104     89   
                    .map_err(crate::operation::update_task_protection::UpdateTaskProtectionError::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   
        "UnsupportedFeatureException" => crate::operation::update_task_protection::UpdateTaskProtectionError::UnsupportedFeatureException({
  114     96   
            #[allow(unused_mut)]
  115     97   
            let mut tmp = {
  116     98   
                #[allow(unused_mut)]
  117     99   
                let mut output = crate::types::error::builders::UnsupportedFeatureExceptionBuilder::default();
  118    100   
                output =
  119    101   
                    crate::protocol_serde::shape_unsupported_feature_exception::de_unsupported_feature_exception_json_err(_response_body, output)
  120    102   
                        .map_err(crate::operation::update_task_protection::UpdateTaskProtectionError::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::update_task_protection::UpdateTaskProtectionError::generic(generic),
  130    109   
    })
  131    110   
}
  132    111   
  133    112   
#[allow(clippy::unnecessary_wraps)]
  134    113   
pub fn de_update_task_protection_http_response(
  135    114   
    _response_status: u16,
  136    115   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/ecs/src/protocol_serde/shape_update_task_set.rs

@@ -1,1 +183,156 @@
   20     20   
        "AccessDeniedException" => crate::operation::update_task_set::UpdateTaskSetError::AccessDeniedException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::update_task_set::UpdateTaskSetError::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   
        "ClientException" => crate::operation::update_task_set::UpdateTaskSetError::ClientException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ClientExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_client_exception::de_client_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::update_task_set::UpdateTaskSetError::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   
        "ClusterNotFoundException" => crate::operation::update_task_set::UpdateTaskSetError::ClusterNotFoundException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ClusterNotFoundExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_cluster_not_found_exception::de_cluster_not_found_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::update_task_set::UpdateTaskSetError::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   
        "InvalidParameterException" => crate::operation::update_task_set::UpdateTaskSetError::InvalidParameterException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::update_task_set::UpdateTaskSetError::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   
        "ServerException" => crate::operation::update_task_set::UpdateTaskSetError::ServerException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::update_task_set::UpdateTaskSetError::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   
        "ServiceNotActiveException" => crate::operation::update_task_set::UpdateTaskSetError::ServiceNotActiveException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::ServiceNotActiveExceptionBuilder::default();
  100     85   
                output = crate::protocol_serde::shape_service_not_active_exception::de_service_not_active_exception_json_err(_response_body, output)
  101     86   
                    .map_err(crate::operation::update_task_set::UpdateTaskSetError::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   
        "ServiceNotFoundException" => crate::operation::update_task_set::UpdateTaskSetError::ServiceNotFoundException({
  111     93   
            #[allow(unused_mut)]
  112     94   
            let mut tmp = {
  113     95   
                #[allow(unused_mut)]
  114     96   
                let mut output = crate::types::error::builders::ServiceNotFoundExceptionBuilder::default();
  115     97   
                output = crate::protocol_serde::shape_service_not_found_exception::de_service_not_found_exception_json_err(_response_body, output)
  116     98   
                    .map_err(crate::operation::update_task_set::UpdateTaskSetError::unhandled)?;
  117     99   
                let output = output.meta(generic);
  118    100   
                output.build()
  119    101   
            };
  120         -
            if tmp.message.is_none() {
  121         -
                tmp.message = _error_message;
  122         -
            }
  123    102   
            tmp
  124    103   
        }),
  125    104   
        "TaskSetNotFoundException" => crate::operation::update_task_set::UpdateTaskSetError::TaskSetNotFoundException({
  126    105   
            #[allow(unused_mut)]
  127    106   
            let mut tmp = {
  128    107   
                #[allow(unused_mut)]
  129    108   
                let mut output = crate::types::error::builders::TaskSetNotFoundExceptionBuilder::default();
  130    109   
                output = crate::protocol_serde::shape_task_set_not_found_exception::de_task_set_not_found_exception_json_err(_response_body, output)
  131    110   
                    .map_err(crate::operation::update_task_set::UpdateTaskSetError::unhandled)?;
  132    111   
                let output = output.meta(generic);
  133    112   
                output.build()
  134    113   
            };
  135         -
            if tmp.message.is_none() {
  136         -
                tmp.message = _error_message;
  137         -
            }
  138    114   
            tmp
  139    115   
        }),
  140    116   
        "UnsupportedFeatureException" => crate::operation::update_task_set::UpdateTaskSetError::UnsupportedFeatureException({
  141    117   
            #[allow(unused_mut)]
  142    118   
            let mut tmp = {
  143    119   
                #[allow(unused_mut)]
  144    120   
                let mut output = crate::types::error::builders::UnsupportedFeatureExceptionBuilder::default();
  145    121   
                output =
  146    122   
                    crate::protocol_serde::shape_unsupported_feature_exception::de_unsupported_feature_exception_json_err(_response_body, output)
  147    123   
                        .map_err(crate::operation::update_task_set::UpdateTaskSetError::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::update_task_set::UpdateTaskSetError::generic(generic),
  157    130   
    })
  158    131   
}
  159    132   
  160    133   
#[allow(clippy::unnecessary_wraps)]
  161    134   
pub fn de_update_task_set_http_response(
  162    135   
    _response_status: u16,
  163    136   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -6,6 +109,97 @@
   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::abort_multipart_upload::AbortMultipartUploadError::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::abort_multipart_upload::AbortMultipartUploadError::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::abort_multipart_upload::AbortMultipartUploadError::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::abort_multipart_upload::AbortMultipartUploadError::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::abort_multipart_upload::AbortMultipartUploadError::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::abort_multipart_upload::AbortMultipartUploadError::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::abort_multipart_upload::AbortMultipartUploadError::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::abort_multipart_upload::AbortMultipartUploadError::generic(generic),
   91     79   
    })
   92     80   
}
   93     81   
   94     82   
#[allow(clippy::unnecessary_wraps)]
   95     83   
pub fn de_abort_multipart_upload_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_abort_vault_lock.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::abort_vault_lock::AbortVaultLockError::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::abort_vault_lock::AbortVaultLockError::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::abort_vault_lock::AbortVaultLockError::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::abort_vault_lock::AbortVaultLockError::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::abort_vault_lock::AbortVaultLockError::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::abort_vault_lock::AbortVaultLockError::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::abort_vault_lock::AbortVaultLockError::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::abort_vault_lock::AbortVaultLockError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_abort_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_add_tags_to_vault.rs

@@ -3,3 +128,113 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::add_tags_to_vault::AddTagsToVaultError::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::add_tags_to_vault::AddTagsToVaultError::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::add_tags_to_vault::AddTagsToVaultError::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::add_tags_to_vault::AddTagsToVaultError::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::add_tags_to_vault::AddTagsToVaultError::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   
        "ResourceNotFoundException" => crate::operation::add_tags_to_vault::AddTagsToVaultError::ResourceNotFoundException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::add_tags_to_vault::AddTagsToVaultError::unhandled)?;
   78     69   
                let output = output.meta(generic);
   79     70   
                output.build()
   80     71   
            };
   81         -
            if tmp.message.is_none() {
   82         -
                tmp.message = _error_message;
   83         -
            }
   84     72   
            tmp
   85     73   
        }),
   86     74   
        "ServiceUnavailableException" => crate::operation::add_tags_to_vault::AddTagsToVaultError::ServiceUnavailableException({
   87     75   
            #[allow(unused_mut)]
   88     76   
            let mut tmp = {
   89     77   
                #[allow(unused_mut)]
   90     78   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   91     79   
                output =
   92     80   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   93     81   
                        .map_err(crate::operation::add_tags_to_vault::AddTagsToVaultError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        _ => crate::operation::add_tags_to_vault::AddTagsToVaultError::generic(generic),
  103     88   
    })
  104     89   
}
  105     90   
  106     91   
#[allow(clippy::unnecessary_wraps)]
  107     92   
pub fn de_add_tags_to_vault_http_response(
  108     93   
    _response_status: u16,
  109     94   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_complete_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::complete_multipart_upload::CompleteMultipartUploadError::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::complete_multipart_upload::CompleteMultipartUploadError::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::complete_multipart_upload::CompleteMultipartUploadError::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::complete_multipart_upload::CompleteMultipartUploadError::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::complete_multipart_upload::CompleteMultipartUploadError::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::complete_multipart_upload::CompleteMultipartUploadError::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::complete_multipart_upload::CompleteMultipartUploadError::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::complete_multipart_upload::CompleteMultipartUploadError::generic(generic),
   99     87   
    })
  100     88   
}
  101     89   
  102     90   
#[allow(clippy::unnecessary_wraps)]
  103     91   
pub fn de_complete_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_complete_vault_lock.rs

@@ -4,4 +105,93 @@
   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::complete_vault_lock::CompleteVaultLockError::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::complete_vault_lock::CompleteVaultLockError::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::complete_vault_lock::CompleteVaultLockError::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::complete_vault_lock::CompleteVaultLockError::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::complete_vault_lock::CompleteVaultLockError::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::complete_vault_lock::CompleteVaultLockError::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::complete_vault_lock::CompleteVaultLockError::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::complete_vault_lock::CompleteVaultLockError::generic(generic),
   89     77   
    })
   90     78   
}
   91     79   
   92     80   
#[allow(clippy::unnecessary_wraps)]
   93     81   
pub fn de_complete_vault_lock_http_response(
   94     82   
    _response_status: u16,
   95     83   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,