AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df

Files changed:

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

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

@@ -3,3 +95,86 @@
   23     23   
        "ClientException" => crate::operation::list_task_definition_families::ListTaskDefinitionFamiliesError::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::list_task_definition_families::ListTaskDefinitionFamiliesError::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::list_task_definition_families::ListTaskDefinitionFamiliesError::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::list_task_definition_families::ListTaskDefinitionFamiliesError::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::list_task_definition_families::ListTaskDefinitionFamiliesError::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::list_task_definition_families::ListTaskDefinitionFamiliesError::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::list_task_definition_families::ListTaskDefinitionFamiliesError::generic(generic),
   69     60   
    })
   70     61   
}
   71     62   
   72     63   
#[allow(clippy::unnecessary_wraps)]
   73     64   
pub fn de_list_task_definition_families_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_list_task_definitions.rs

@@ -3,3 +95,86 @@
   23     23   
        "ClientException" => crate::operation::list_task_definitions::ListTaskDefinitionsError::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::list_task_definitions::ListTaskDefinitionsError::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::list_task_definitions::ListTaskDefinitionsError::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::list_task_definitions::ListTaskDefinitionsError::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::list_task_definitions::ListTaskDefinitionsError::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::list_task_definitions::ListTaskDefinitionsError::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::list_task_definitions::ListTaskDefinitionsError::generic(generic),
   69     60   
    })
   70     61   
}
   71     62   
   72     63   
#[allow(clippy::unnecessary_wraps)]
   73     64   
pub fn de_list_task_definitions_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_list_tasks.rs

@@ -1,1 +122,107 @@
   20     20   
        "ClientException" => crate::operation::list_tasks::ListTasksError::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::list_tasks::ListTasksError::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::list_tasks::ListTasksError::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::list_tasks::ListTasksError::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::list_tasks::ListTasksError::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::list_tasks::ListTasksError::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::list_tasks::ListTasksError::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::list_tasks::ListTasksError::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::list_tasks::ListTasksError::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::list_tasks::ListTasksError::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::list_tasks::ListTasksError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_list_tasks_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_put_account_setting.rs

@@ -1,1 +93,84 @@
   21     21   
        "ClientException" => crate::operation::put_account_setting::PutAccountSettingError::ClientException({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::ClientExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_client_exception::de_client_exception_json_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::put_account_setting::PutAccountSettingError::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   
        "InvalidParameterException" => crate::operation::put_account_setting::PutAccountSettingError::InvalidParameterException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::put_account_setting::PutAccountSettingError::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   
        "ServerException" => crate::operation::put_account_setting::PutAccountSettingError::ServerException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::put_account_setting::PutAccountSettingError::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   
        _ => crate::operation::put_account_setting::PutAccountSettingError::generic(generic),
   67     58   
    })
   68     59   
}
   69     60   
   70     61   
#[allow(clippy::unnecessary_wraps)]
   71     62   
pub fn de_put_account_setting_http_response(
   72     63   
    _response_status: u16,
   73     64   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

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

@@ -3,3 +110,98 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::AttributeLimitExceededExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_attribute_limit_exceeded_exception::de_attribute_limit_exceeded_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::put_attributes::PutAttributesError::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::put_attributes::PutAttributesError::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::put_attributes::PutAttributesError::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::put_attributes::PutAttributesError::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::put_attributes::PutAttributesError::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   
        "TargetNotFoundException" => crate::operation::put_attributes::PutAttributesError::TargetNotFoundException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::TargetNotFoundExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_target_not_found_exception::de_target_not_found_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::put_attributes::PutAttributesError::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::put_attributes::PutAttributesError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_put_attributes_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_put_cluster_capacity_providers.rs

@@ -3,3 +145,127 @@
   23     23   
        "ClientException" => crate::operation::put_cluster_capacity_providers::PutClusterCapacityProvidersError::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::put_cluster_capacity_providers::PutClusterCapacityProvidersError::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::put_cluster_capacity_providers::PutClusterCapacityProvidersError::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::put_cluster_capacity_providers::PutClusterCapacityProvidersError::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::put_cluster_capacity_providers::PutClusterCapacityProvidersError::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::put_cluster_capacity_providers::PutClusterCapacityProvidersError::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   
        "ResourceInUseException" => crate::operation::put_cluster_capacity_providers::PutClusterCapacityProvidersError::ResourceInUseException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::put_cluster_capacity_providers::PutClusterCapacityProvidersError::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   
        "ServerException" => crate::operation::put_cluster_capacity_providers::PutClusterCapacityProvidersError::ServerException({
   87     75   
            #[allow(unused_mut)]
   88     76   
            let mut tmp = {
   89     77   
                #[allow(unused_mut)]
   90     78   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
   91     79   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
   92     80   
                    .map_err(crate::operation::put_cluster_capacity_providers::PutClusterCapacityProvidersError::unhandled)?;
   93     81   
                let output = output.meta(generic);
   94     82   
                output.build()
   95     83   
            };
   96         -
            if tmp.message.is_none() {
   97         -
                tmp.message = _error_message;
   98         -
            }
   99     84   
            tmp
  100     85   
        }),
  101     86   
        "UpdateInProgressException" => {
  102     87   
            crate::operation::put_cluster_capacity_providers::PutClusterCapacityProvidersError::UpdateInProgressException({
  103     88   
                #[allow(unused_mut)]
  104     89   
                let mut tmp = {
  105     90   
                    #[allow(unused_mut)]
  106     91   
                    let mut output = crate::types::error::builders::UpdateInProgressExceptionBuilder::default();
  107     92   
                    output =
  108     93   
                        crate::protocol_serde::shape_update_in_progress_exception::de_update_in_progress_exception_json_err(_response_body, output)
  109     94   
                            .map_err(crate::operation::put_cluster_capacity_providers::PutClusterCapacityProvidersError::unhandled)?;
  110     95   
                    let output = output.meta(generic);
  111     96   
                    output.build()
  112     97   
                };
  113         -
                if tmp.message.is_none() {
  114         -
                    tmp.message = _error_message;
  115         -
                }
  116     98   
                tmp
  117     99   
            })
  118    100   
        }
  119    101   
        _ => crate::operation::put_cluster_capacity_providers::PutClusterCapacityProvidersError::generic(generic),
  120    102   
    })
  121    103   
}
  122    104   
  123    105   
#[allow(clippy::unnecessary_wraps)]
  124    106   
pub fn de_put_cluster_capacity_providers_http_response(
  125    107   
    _response_status: u16,

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

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

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

@@ -1,1 +199,169 @@
   20     20   
        "AccessDeniedException" => crate::operation::run_task::RunTaskError::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::run_task::RunTaskError::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   
        "BlockedException" => crate::operation::run_task::RunTaskError::BlockedException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::BlockedExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_blocked_exception::de_blocked_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::run_task::RunTaskError::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   
        "ClientException" => crate::operation::run_task::RunTaskError::ClientException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ClientExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_client_exception::de_client_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::run_task::RunTaskError::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   
        "ClusterNotFoundException" => crate::operation::run_task::RunTaskError::ClusterNotFoundException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ClusterNotFoundExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_cluster_not_found_exception::de_cluster_not_found_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::run_task::RunTaskError::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   
        "ConflictException" => crate::operation::run_task::RunTaskError::ConflictException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::run_task::RunTaskError::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   
        "InvalidParameterException" => crate::operation::run_task::RunTaskError::InvalidParameterException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
  100     85   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
  101     86   
                    .map_err(crate::operation::run_task::RunTaskError::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   
        "PlatformTaskDefinitionIncompatibilityException" => {
  111     93   
            crate::operation::run_task::RunTaskError::PlatformTaskDefinitionIncompatibilityException({
  112     94   
                #[allow(unused_mut)]
  113     95   
                let mut tmp = {
  114     96   
                    #[allow(unused_mut)]
  115     97   
                    let mut output = crate::types::error::builders::PlatformTaskDefinitionIncompatibilityExceptionBuilder::default();
  116     98   
                    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::run_task::RunTaskError::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   
        }
  126    105   
        "PlatformUnknownException" => crate::operation::run_task::RunTaskError::PlatformUnknownException({
  127    106   
            #[allow(unused_mut)]
  128    107   
            let mut tmp = {
  129    108   
                #[allow(unused_mut)]
  130    109   
                let mut output = crate::types::error::builders::PlatformUnknownExceptionBuilder::default();
  131    110   
                output = crate::protocol_serde::shape_platform_unknown_exception::de_platform_unknown_exception_json_err(_response_body, output)
  132    111   
                    .map_err(crate::operation::run_task::RunTaskError::unhandled)?;
  133    112   
                let output = output.meta(generic);
  134    113   
                output.build()
  135    114   
            };
  136         -
            if tmp.message.is_none() {
  137         -
                tmp.message = _error_message;
  138         -
            }
  139    115   
            tmp
  140    116   
        }),
  141    117   
        "ServerException" => crate::operation::run_task::RunTaskError::ServerException({
  142    118   
            #[allow(unused_mut)]
  143    119   
            let mut tmp = {
  144    120   
                #[allow(unused_mut)]
  145    121   
                let mut output = crate::types::error::builders::ServerExceptionBuilder::default();
  146    122   
                output = crate::protocol_serde::shape_server_exception::de_server_exception_json_err(_response_body, output)
  147    123   
                    .map_err(crate::operation::run_task::RunTaskError::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   
        "UnsupportedFeatureException" => crate::operation::run_task::RunTaskError::UnsupportedFeatureException({
  157    130   
            #[allow(unused_mut)]
  158    131   
            let mut tmp = {
  159    132   
                #[allow(unused_mut)]
  160    133   
                let mut output = crate::types::error::builders::UnsupportedFeatureExceptionBuilder::default();
  161    134   
                output =
  162    135   
                    crate::protocol_serde::shape_unsupported_feature_exception::de_unsupported_feature_exception_json_err(_response_body, output)
  163    136   
                        .map_err(crate::operation::run_task::RunTaskError::unhandled)?;
  164    137   
                let output = output.meta(generic);
  165    138   
                output.build()
  166    139   
            };
  167         -
            if tmp.message.is_none() {
  168         -
                tmp.message = _error_message;
  169         -
            }
  170    140   
            tmp
  171    141   
        }),
  172    142   
        _ => crate::operation::run_task::RunTaskError::generic(generic),
  173    143   
    })
  174    144   
}
  175    145   
  176    146   
#[allow(clippy::unnecessary_wraps)]
  177    147   
pub fn de_run_task_http_response(
  178    148   
    _response_status: u16,
  179    149   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +123,108 @@
   20     20   
        "ClientException" => crate::operation::start_task::StartTaskError::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::start_task::StartTaskError::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::start_task::StartTaskError::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::start_task::StartTaskError::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::start_task::StartTaskError::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::start_task::StartTaskError::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::start_task::StartTaskError::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::start_task::StartTaskError::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   
        "UnsupportedFeatureException" => crate::operation::start_task::StartTaskError::UnsupportedFeatureException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::UnsupportedFeatureExceptionBuilder::default();
   85     73   
                output =
   86     74   
                    crate::protocol_serde::shape_unsupported_feature_exception::de_unsupported_feature_exception_json_err(_response_body, output)
   87     75   
                        .map_err(crate::operation::start_task::StartTaskError::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::start_task::StartTaskError::generic(generic),
   97     82   
    })
   98     83   
}
   99     84   
  100     85   
#[allow(clippy::unnecessary_wraps)]
  101     86   
pub fn de_start_task_http_response(
  102     87   
    _response_status: u16,
  103     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

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

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

@@ -3,3 +113,101 @@
   23     23   
        "AccessDeniedException" => crate::operation::submit_attachment_state_changes::SubmitAttachmentStateChangesError::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::submit_attachment_state_changes::SubmitAttachmentStateChangesError::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::submit_attachment_state_changes::SubmitAttachmentStateChangesError::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::submit_attachment_state_changes::SubmitAttachmentStateChangesError::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::submit_attachment_state_changes::SubmitAttachmentStateChangesError::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::submit_attachment_state_changes::SubmitAttachmentStateChangesError::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::submit_attachment_state_changes::SubmitAttachmentStateChangesError::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::submit_attachment_state_changes::SubmitAttachmentStateChangesError::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::submit_attachment_state_changes::SubmitAttachmentStateChangesError::generic(generic),
   87     75   
    })
   88     76   
}
   89     77   
   90     78   
#[allow(clippy::unnecessary_wraps)]
   91     79   
pub fn de_submit_attachment_state_changes_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_submit_container_state_change.rs

@@ -3,3 +95,86 @@
   23     23   
        "AccessDeniedException" => crate::operation::submit_container_state_change::SubmitContainerStateChangeError::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::submit_container_state_change::SubmitContainerStateChangeError::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::submit_container_state_change::SubmitContainerStateChangeError::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::submit_container_state_change::SubmitContainerStateChangeError::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::submit_container_state_change::SubmitContainerStateChangeError::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::submit_container_state_change::SubmitContainerStateChangeError::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::submit_container_state_change::SubmitContainerStateChangeError::generic(generic),
   69     60   
    })
   70     61   
}
   71     62   
   72     63   
#[allow(clippy::unnecessary_wraps)]
   73     64   
pub fn de_submit_container_state_change_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_submit_task_state_change.rs

@@ -3,3 +110,98 @@
   23     23   
        "AccessDeniedException" => crate::operation::submit_task_state_change::SubmitTaskStateChangeError::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::submit_task_state_change::SubmitTaskStateChangeError::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::submit_task_state_change::SubmitTaskStateChangeError::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::submit_task_state_change::SubmitTaskStateChangeError::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::submit_task_state_change::SubmitTaskStateChangeError::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::submit_task_state_change::SubmitTaskStateChangeError::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::submit_task_state_change::SubmitTaskStateChangeError::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::submit_task_state_change::SubmitTaskStateChangeError::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::submit_task_state_change::SubmitTaskStateChangeError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_submit_task_state_change_http_response(
   89     77   
    _response_status: u16,
   90     78   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,