AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df

Files changed:

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_update_table_replica_auto_scaling.rs

@@ -3,3 +116,104 @@
   23     23   
        "InternalServerError" => crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::InternalServerError({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::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" => {
   39     36   
            crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::LimitExceededException({
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut tmp = {
   42     39   
                    #[allow(unused_mut)]
   43     40   
                    let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   44     41   
                    output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   45     42   
                        .map_err(crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::unhandled)?;
   46     43   
                    let output = output.meta(generic);
   47     44   
                    output.build()
   48     45   
                };
   49         -
                if tmp.message.is_none() {
   50         -
                    tmp.message = _error_message;
   51         -
                }
   52     46   
                tmp
   53     47   
            })
   54     48   
        }
   55     49   
        "ResourceInUseException" => {
   56     50   
            crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::ResourceInUseException({
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut tmp = {
   59     53   
                    #[allow(unused_mut)]
   60     54   
                    let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   61     55   
                    output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   62     56   
                        .map_err(crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::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   
        }
   72     63   
        "ResourceNotFoundException" => {
   73     64   
            crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::ResourceNotFoundException({
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut tmp = {
   76     67   
                    #[allow(unused_mut)]
   77     68   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   78     69   
                    output =
   79     70   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   80     71   
                            .map_err(crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::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   
        }
   90     78   
        _ => crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::generic(generic),
   91     79   
    })
   92     80   
}
   93     81   
   94     82   
#[allow(clippy::unnecessary_wraps)]
   95     83   
pub fn de_update_table_replica_auto_scaling_http_response(
   96     84   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/protocol_serde/shape_update_time_to_live.rs

@@ -1,1 +123,108 @@
   21     21   
        "InternalServerError" => crate::operation::update_time_to_live::UpdateTimeToLiveError::InternalServerError({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::update_time_to_live::UpdateTimeToLiveError::unhandled)?;
   28     28   
                let output = output.meta(generic);
   29     29   
                output.build()
   30     30   
            };
   31         -
            if tmp.message.is_none() {
   32         -
                tmp.message = _error_message;
   33         -
            }
   34     31   
            tmp
   35     32   
        }),
   36     33   
        "InvalidEndpointException" => crate::operation::update_time_to_live::UpdateTimeToLiveError::InvalidEndpointException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::update_time_to_live::UpdateTimeToLiveError::unhandled)?;
   43     40   
                let output = output.meta(generic);
   44     41   
                output.build()
   45     42   
            };
   46         -
            if tmp.message.is_none() {
   47         -
                tmp.message = _error_message;
   48         -
            }
   49     43   
            tmp
   50     44   
        }),
   51     45   
        "LimitExceededException" => crate::operation::update_time_to_live::UpdateTimeToLiveError::LimitExceededException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::update_time_to_live::UpdateTimeToLiveError::unhandled)?;
   58     52   
                let output = output.meta(generic);
   59     53   
                output.build()
   60     54   
            };
   61         -
            if tmp.message.is_none() {
   62         -
                tmp.message = _error_message;
   63         -
            }
   64     55   
            tmp
   65     56   
        }),
   66     57   
        "ResourceInUseException" => crate::operation::update_time_to_live::UpdateTimeToLiveError::ResourceInUseException({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::update_time_to_live::UpdateTimeToLiveError::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   
        "ResourceNotFoundException" => crate::operation::update_time_to_live::UpdateTimeToLiveError::ResourceNotFoundException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   87     75   
                    .map_err(crate::operation::update_time_to_live::UpdateTimeToLiveError::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_time_to_live::UpdateTimeToLiveError::generic(generic),
   97     82   
    })
   98     83   
}
   99     84   
  100     85   
#[allow(clippy::unnecessary_wraps)]
  101     86   
pub fn de_update_time_to_live_http_response(
  102     87   
    _response_status: u16,
  103     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_cancellation_reason.rs

@@ -1,1 +57,78 @@
   18     18   
    }
   19     19   
    /// <p>Status code for the result of the cancelled transaction.</p>
   20     20   
    pub fn code(&self) -> ::std::option::Option<&str> {
   21     21   
        self.code.as_deref()
   22     22   
    }
   23     23   
    /// <p>Cancellation reason message description.</p>
   24     24   
    pub fn message(&self) -> ::std::option::Option<&str> {
   25     25   
        self.message.as_deref()
   26     26   
    }
   27     27   
}
          28  +
impl ::std::fmt::Display for CancellationReason {
          29  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          30  +
        ::std::write!(f, "CancellationReason {{")?;
          31  +
        if let ::std::option::Option::Some(inner) = &self.item {
          32  +
            ::std::write!(f, "item=Some({})", inner)?;
          33  +
        } else {
          34  +
            ::std::write!(f, "item=None")?;
          35  +
        }
          36  +
        if let ::std::option::Option::Some(inner) = &self.code {
          37  +
            ::std::write!(f, ", code=Some({})", inner)?;
          38  +
        } else {
          39  +
            ::std::write!(f, ", code=None")?;
          40  +
        }
          41  +
        if let ::std::option::Option::Some(inner) = &self.message {
          42  +
            ::std::write!(f, ", message=Some({})", inner)?;
          43  +
        } else {
          44  +
            ::std::write!(f, ", message=None")?;
          45  +
        }
          46  +
        ::std::write!(f, "}}")
          47  +
    }
          48  +
}
   28     49   
impl CancellationReason {
   29     50   
    /// Creates a new builder-style object to manufacture [`CancellationReason`](crate::types::CancellationReason).
   30     51   
    pub fn builder() -> crate::types::builders::CancellationReasonBuilder {
   31     52   
        crate::types::builders::CancellationReasonBuilder::default()
   32     53   
    }
   33     54   
}
   34     55   
   35     56   
/// A builder for [`CancellationReason`](crate::types::CancellationReason).
   36     57   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   37     58   
#[non_exhaustive]

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

@@ -7,7 +129,114 @@
   27     27   
        "ClientException" => crate::operation::create_capacity_provider::CreateCapacityProviderError::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::create_capacity_provider::CreateCapacityProviderError::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::create_capacity_provider::CreateCapacityProviderError::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::create_capacity_provider::CreateCapacityProviderError::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   
        "LimitExceededException" => crate::operation::create_capacity_provider::CreateCapacityProviderError::LimitExceededException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::create_capacity_provider::CreateCapacityProviderError::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   
        "ServerException" => crate::operation::create_capacity_provider::CreateCapacityProviderError::ServerException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::create_capacity_provider::CreateCapacityProviderError::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   
        "UpdateInProgressException" => crate::operation::create_capacity_provider::CreateCapacityProviderError::UpdateInProgressException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::UpdateInProgressExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_update_in_progress_exception::de_update_in_progress_exception_json_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::create_capacity_provider::CreateCapacityProviderError::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::create_capacity_provider::CreateCapacityProviderError::generic(generic),
  103     88   
    })
  104     89   
}
  105     90   
  106     91   
#[allow(clippy::unnecessary_wraps)]
  107     92   
pub fn de_create_capacity_provider_http_response(
  108     93   
    _response_status: u16,
  109     94   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +108,96 @@
   20     20   
        "ClientException" => crate::operation::create_cluster::CreateClusterError::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::create_cluster::CreateClusterError::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   
        "InvalidParameterException" => crate::operation::create_cluster::CreateClusterError::InvalidParameterException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::create_cluster::CreateClusterError::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   
        "NamespaceNotFoundException" => crate::operation::create_cluster::CreateClusterError::NamespaceNotFoundException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::NamespaceNotFoundExceptionBuilder::default();
   55     49   
                output =
   56     50   
                    crate::protocol_serde::shape_namespace_not_found_exception::de_namespace_not_found_exception_json_err(_response_body, output)
   57     51   
                        .map_err(crate::operation::create_cluster::CreateClusterError::unhandled)?;
   58     52   
                let output = output.meta(generic);
   59     53   
                output.build()
   60     54   
            };
   61         -
            if tmp.message.is_none() {
   62         -
                tmp.message = _error_message;
   63         -
            }
   64     55   
            tmp
   65     56   
        }),
   66     57   
        "ServerException" => crate::operation::create_cluster::CreateClusterError::ServerException({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::create_cluster::CreateClusterError::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   
        _ => crate::operation::create_cluster::CreateClusterError::generic(generic),
   82     70   
    })
   83     71   
}
   84     72   
   85     73   
#[allow(clippy::unnecessary_wraps)]
   86     74   
pub fn de_create_cluster_http_response(
   87     75   
    _response_status: u16,
   88     76   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +185,158 @@
   20     20   
        "AccessDeniedException" => crate::operation::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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::create_service::CreateServiceError::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   
        "UnsupportedFeatureException" => crate::operation::create_service::CreateServiceError::UnsupportedFeatureException({
  143    119   
            #[allow(unused_mut)]
  144    120   
            let mut tmp = {
  145    121   
                #[allow(unused_mut)]
  146    122   
                let mut output = crate::types::error::builders::UnsupportedFeatureExceptionBuilder::default();
  147    123   
                output =
  148    124   
                    crate::protocol_serde::shape_unsupported_feature_exception::de_unsupported_feature_exception_json_err(_response_body, output)
  149    125   
                        .map_err(crate::operation::create_service::CreateServiceError::unhandled)?;
  150    126   
                let output = output.meta(generic);
  151    127   
                output.build()
  152    128   
            };
  153         -
            if tmp.message.is_none() {
  154         -
                tmp.message = _error_message;
  155         -
            }
  156    129   
            tmp
  157    130   
        }),
  158    131   
        _ => crate::operation::create_service::CreateServiceError::generic(generic),
  159    132   
    })
  160    133   
}
  161    134   
  162    135   
#[allow(clippy::unnecessary_wraps)]
  163    136   
pub fn de_create_service_http_response(
  164    137   
    _response_status: u16,
  165    138   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +215,182 @@
   20     20   
        "AccessDeniedException" => crate::operation::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::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::create_task_set::CreateTaskSetError::generic(generic),
  189    156   
    })
  190    157   
}
  191    158   
  192    159   
#[allow(clippy::unnecessary_wraps)]
  193    160   
pub fn de_create_task_set_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_delete_account_setting.rs

@@ -3,3 +95,86 @@
   23     23   
        "ClientException" => crate::operation::delete_account_setting::DeleteAccountSettingError::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::delete_account_setting::DeleteAccountSettingError::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   
        "InvalidParameterException" => crate::operation::delete_account_setting::DeleteAccountSettingError::InvalidParameterException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::delete_account_setting::DeleteAccountSettingError::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   
        "ServerException" => crate::operation::delete_account_setting::DeleteAccountSettingError::ServerException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::delete_account_setting::DeleteAccountSettingError::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   
        _ => crate::operation::delete_account_setting::DeleteAccountSettingError::generic(generic),
   69     60   
    })
   70     61   
}
   71     62   
   72     63   
#[allow(clippy::unnecessary_wraps)]
   73     64   
pub fn de_delete_account_setting_http_response(
   74     65   
    _response_status: u16,
   75     66   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +92,83 @@
   20     20   
        "ClusterNotFoundException" => crate::operation::delete_attributes::DeleteAttributesError::ClusterNotFoundException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ClusterNotFoundExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_cluster_not_found_exception::de_cluster_not_found_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::delete_attributes::DeleteAttributesError::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   
        "InvalidParameterException" => crate::operation::delete_attributes::DeleteAttributesError::InvalidParameterException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::delete_attributes::DeleteAttributesError::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   
        "TargetNotFoundException" => crate::operation::delete_attributes::DeleteAttributesError::TargetNotFoundException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::TargetNotFoundExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_target_not_found_exception::de_target_not_found_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::delete_attributes::DeleteAttributesError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        _ => crate::operation::delete_attributes::DeleteAttributesError::generic(generic),
   66     57   
    })
   67     58   
}
   68     59   
   69     60   
#[allow(clippy::unnecessary_wraps)]
   70     61   
pub fn de_delete_attributes_http_response(
   71     62   
    _response_status: u16,
   72     63   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +99,90 @@
   27     27   
        "ClientException" => crate::operation::delete_capacity_provider::DeleteCapacityProviderError::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::delete_capacity_provider::DeleteCapacityProviderError::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::delete_capacity_provider::DeleteCapacityProviderError::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::delete_capacity_provider::DeleteCapacityProviderError::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::delete_capacity_provider::DeleteCapacityProviderError::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::delete_capacity_provider::DeleteCapacityProviderError::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::delete_capacity_provider::DeleteCapacityProviderError::generic(generic),
   73     64   
    })
   74     65   
}
   75     66   
   76     67   
#[allow(clippy::unnecessary_wraps)]
   77     68   
pub fn de_delete_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_delete_cluster.rs

@@ -1,1 +174,150 @@
   20     20   
        "ClientException" => crate::operation::delete_cluster::DeleteClusterError::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::delete_cluster::DeleteClusterError::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   
        "ClusterContainsContainerInstancesException" => {
   36     33   
            crate::operation::delete_cluster::DeleteClusterError::ClusterContainsContainerInstancesException({
   37     34   
                #[allow(unused_mut)]
   38     35   
                let mut tmp = {
   39     36   
                    #[allow(unused_mut)]
   40     37   
                    let mut output = crate::types::error::builders::ClusterContainsContainerInstancesExceptionBuilder::default();
   41     38   
                    output = crate::protocol_serde::shape_cluster_contains_container_instances_exception::de_cluster_contains_container_instances_exception_json_err(_response_body, output).map_err(crate::operation::delete_cluster::DeleteClusterError::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   
        }
   51     45   
        "ClusterContainsServicesException" => crate::operation::delete_cluster::DeleteClusterError::ClusterContainsServicesException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::ClusterContainsServicesExceptionBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_cluster_contains_services_exception::de_cluster_contains_services_exception_json_err(
   57     51   
                    _response_body,
   58     52   
                    output,
   59     53   
                )
   60     54   
                .map_err(crate::operation::delete_cluster::DeleteClusterError::unhandled)?;
   61     55   
                let output = output.meta(generic);
   62     56   
                output.build()
   63     57   
            };
   64         -
            if tmp.message.is_none() {
   65         -
                tmp.message = _error_message;
   66         -
            }
   67     58   
            tmp
   68     59   
        }),
   69     60   
        "ClusterContainsTasksException" => crate::operation::delete_cluster::DeleteClusterError::ClusterContainsTasksException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::ClusterContainsTasksExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_cluster_contains_tasks_exception::de_cluster_contains_tasks_exception_json_err(
   75     66   
                    _response_body,
   76     67   
                    output,
   77     68   
                )
   78     69   
                .map_err(crate::operation::delete_cluster::DeleteClusterError::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   
        "ClusterNotFoundException" => crate::operation::delete_cluster::DeleteClusterError::ClusterNotFoundException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::ClusterNotFoundExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_cluster_not_found_exception::de_cluster_not_found_exception_json_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::delete_cluster::DeleteClusterError::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   
        "InvalidParameterException" => crate::operation::delete_cluster::DeleteClusterError::InvalidParameterException({
  103     88   
            #[allow(unused_mut)]
  104     89   
            let mut tmp = {
  105     90   
                #[allow(unused_mut)]
  106     91   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
  107     92   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
  108     93   
                    .map_err(crate::operation::delete_cluster::DeleteClusterError::unhandled)?;
  109     94   
                let output = output.meta(generic);
  110     95   
                output.build()
  111     96   
            };
  112         -
            if tmp.message.is_none() {
  113         -
                tmp.message = _error_message;
  114         -
            }
  115     97   
            tmp
  116     98   
        }),
  117     99   
        "ServerException" => crate::operation::delete_cluster::DeleteClusterError::ServerException({
  118    100   
            #[allow(unused_mut)]
  119    101   
            let mut tmp = {
  120    102   
                #[allow(unused_mut)]
  121    103   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
  122    104   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
  123    105   
                    .map_err(crate::operation::delete_cluster::DeleteClusterError::unhandled)?;
  124    106   
                let output = output.meta(generic);
  125    107   
                output.build()
  126    108   
            };
  127         -
            if tmp.message.is_none() {
  128         -
                tmp.message = _error_message;
  129         -
            }
  130    109   
            tmp
  131    110   
        }),
  132    111   
        "UpdateInProgressException" => crate::operation::delete_cluster::DeleteClusterError::UpdateInProgressException({
  133    112   
            #[allow(unused_mut)]
  134    113   
            let mut tmp = {
  135    114   
                #[allow(unused_mut)]
  136    115   
                let mut output = crate::types::error::builders::UpdateInProgressExceptionBuilder::default();
  137    116   
                output = crate::protocol_serde::shape_update_in_progress_exception::de_update_in_progress_exception_json_err(_response_body, output)
  138    117   
                    .map_err(crate::operation::delete_cluster::DeleteClusterError::unhandled)?;
  139    118   
                let output = output.meta(generic);
  140    119   
                output.build()
  141    120   
            };
  142         -
            if tmp.message.is_none() {
  143         -
                tmp.message = _error_message;
  144         -
            }
  145    121   
            tmp
  146    122   
        }),
  147    123   
        _ => crate::operation::delete_cluster::DeleteClusterError::generic(generic),
  148    124   
    })
  149    125   
}
  150    126   
  151    127   
#[allow(clippy::unnecessary_wraps)]
  152    128   
pub fn de_delete_cluster_http_response(
  153    129   
    _response_status: u16,
  154    130   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +122,107 @@
   20     20   
        "ClientException" => crate::operation::delete_service::DeleteServiceError::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::delete_service::DeleteServiceError::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::delete_service::DeleteServiceError::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::delete_service::DeleteServiceError::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::delete_service::DeleteServiceError::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::delete_service::DeleteServiceError::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   
        "ServerException" => crate::operation::delete_service::DeleteServiceError::ServerException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::delete_service::DeleteServiceError::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   
        "ServiceNotFoundException" => crate::operation::delete_service::DeleteServiceError::ServiceNotFoundException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::ServiceNotFoundExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_service_not_found_exception::de_service_not_found_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::delete_service::DeleteServiceError::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::delete_service::DeleteServiceError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_delete_service_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_delete_task_definitions.rs

@@ -3,3 +110,98 @@
   23     23   
        "AccessDeniedException" => crate::operation::delete_task_definitions::DeleteTaskDefinitionsError::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::delete_task_definitions::DeleteTaskDefinitionsError::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::delete_task_definitions::DeleteTaskDefinitionsError::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::delete_task_definitions::DeleteTaskDefinitionsError::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::delete_task_definitions::DeleteTaskDefinitionsError::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::delete_task_definitions::DeleteTaskDefinitionsError::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::delete_task_definitions::DeleteTaskDefinitionsError::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::delete_task_definitions::DeleteTaskDefinitionsError::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::delete_task_definitions::DeleteTaskDefinitionsError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_delete_task_definitions_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_delete_task_set.rs

@@ -1,1 +183,156 @@
   20     20   
        "AccessDeniedException" => crate::operation::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::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::delete_task_set::DeleteTaskSetError::generic(generic),
  157    130   
    })
  158    131   
}
  159    132   
  160    133   
#[allow(clippy::unnecessary_wraps)]
  161    134   
pub fn de_delete_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/ecs/src/protocol_serde/shape_deregister_container_instance.rs

@@ -3,3 +113,101 @@
   23     23   
        "ClientException" => crate::operation::deregister_container_instance::DeregisterContainerInstanceError::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::deregister_container_instance::DeregisterContainerInstanceError::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::deregister_container_instance::DeregisterContainerInstanceError::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::deregister_container_instance::DeregisterContainerInstanceError::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" => {
   54     48   
            crate::operation::deregister_container_instance::DeregisterContainerInstanceError::InvalidParameterException({
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut tmp = {
   57     51   
                    #[allow(unused_mut)]
   58     52   
                    let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   59     53   
                    output =
   60     54   
                        crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   61     55   
                            .map_err(crate::operation::deregister_container_instance::DeregisterContainerInstanceError::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   
        "ServerException" => crate::operation::deregister_container_instance::DeregisterContainerInstanceError::ServerException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::deregister_container_instance::DeregisterContainerInstanceError::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   
        _ => crate::operation::deregister_container_instance::DeregisterContainerInstanceError::generic(generic),
   87     75   
    })
   88     76   
}
   89     77   
   90     78   
#[allow(clippy::unnecessary_wraps)]
   91     79   
pub fn de_deregister_container_instance_http_response(
   92     80   
    _response_status: u16,
   93     81   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +99,90 @@
   27     27   
        "ClientException" => crate::operation::deregister_task_definition::DeregisterTaskDefinitionError::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::deregister_task_definition::DeregisterTaskDefinitionError::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::deregister_task_definition::DeregisterTaskDefinitionError::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::deregister_task_definition::DeregisterTaskDefinitionError::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::deregister_task_definition::DeregisterTaskDefinitionError::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::deregister_task_definition::DeregisterTaskDefinitionError::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::deregister_task_definition::DeregisterTaskDefinitionError::generic(generic),
   73     64   
    })
   74     65   
}
   75     66   
   76     67   
#[allow(clippy::unnecessary_wraps)]
   77     68   
pub fn de_deregister_task_definition_http_response(
   78     69   
    _response_status: u16,
   79     70   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,