AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df (ignoring whitespace)

Files changed:

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

@@ -1,1 +92,83 @@
   20     20   
        "InternalServiceException" => crate::operation::list_jobs::ListJobsError::InternalServiceException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InternalServiceExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_internal_service_exception::de_internal_service_exception_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::list_jobs::ListJobsError::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   
        "InvalidNextTokenException" => crate::operation::list_jobs::ListJobsError::InvalidNextTokenException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::list_jobs::ListJobsError::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   
        "InvalidRequestException" => crate::operation::list_jobs::ListJobsError::InvalidRequestException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidRequestExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_request_exception::de_invalid_request_exception_xml_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::list_jobs::ListJobsError::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::list_jobs::ListJobsError::generic(generic),
   66     57   
    })
   67     58   
}
   68     59   
   69     60   
#[allow(clippy::unnecessary_wraps)]
   70     61   
pub fn de_list_jobs_http_response(
   71     62   
    _response_status: u16,
   72     63   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/s3control/src/protocol_serde/shape_put_job_tagging.rs

@@ -1,1 +107,95 @@
   20     20   
        "InternalServiceException" => crate::operation::put_job_tagging::PutJobTaggingError::InternalServiceException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InternalServiceExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_internal_service_exception::de_internal_service_exception_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::put_job_tagging::PutJobTaggingError::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   
        "NotFoundException" => crate::operation::put_job_tagging::PutJobTaggingError::NotFoundException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::put_job_tagging::PutJobTaggingError::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   
        "TooManyRequestsException" => crate::operation::put_job_tagging::PutJobTaggingError::TooManyRequestsException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_xml_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::put_job_tagging::PutJobTaggingError::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   
        "TooManyTagsException" => crate::operation::put_job_tagging::PutJobTaggingError::TooManyTagsException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::TooManyTagsExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_too_many_tags_exception::de_too_many_tags_exception_xml_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::put_job_tagging::PutJobTaggingError::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::put_job_tagging::PutJobTaggingError::generic(generic),
   81     69   
    })
   82     70   
}
   83     71   
   84     72   
#[allow(clippy::unnecessary_wraps)]
   85     73   
pub fn de_put_job_tagging_http_response(
   86     74   
    _response_status: u16,
   87     75   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/s3control/src/protocol_serde/shape_update_job_priority.rs

@@ -1,1 +108,96 @@
   21     21   
        "BadRequestException" => crate::operation::update_job_priority::UpdateJobPriorityError::BadRequestException({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::BadRequestExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_bad_request_exception::de_bad_request_exception_xml_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::update_job_priority::UpdateJobPriorityError::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   
        "InternalServiceException" => crate::operation::update_job_priority::UpdateJobPriorityError::InternalServiceException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::InternalServiceExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_internal_service_exception::de_internal_service_exception_xml_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::update_job_priority::UpdateJobPriorityError::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   
        "NotFoundException" => crate::operation::update_job_priority::UpdateJobPriorityError::NotFoundException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_xml_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::update_job_priority::UpdateJobPriorityError::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   
        "TooManyRequestsException" => crate::operation::update_job_priority::UpdateJobPriorityError::TooManyRequestsException({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_xml_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::update_job_priority::UpdateJobPriorityError::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::update_job_priority::UpdateJobPriorityError::generic(generic),
   82     70   
    })
   83     71   
}
   84     72   
   85     73   
#[allow(clippy::unnecessary_wraps)]
   86     74   
pub fn de_update_job_priority_http_response(
   87     75   
    _response_status: u16,
   88     76   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/s3control/src/protocol_serde/shape_update_job_status.rs

@@ -1,1 +122,107 @@
   20     20   
        "BadRequestException" => crate::operation::update_job_status::UpdateJobStatusError::BadRequestException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::BadRequestExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_bad_request_exception::de_bad_request_exception_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::update_job_status::UpdateJobStatusError::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   
        "InternalServiceException" => crate::operation::update_job_status::UpdateJobStatusError::InternalServiceException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InternalServiceExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_internal_service_exception::de_internal_service_exception_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::update_job_status::UpdateJobStatusError::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   
        "JobStatusException" => crate::operation::update_job_status::UpdateJobStatusError::JobStatusException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::JobStatusExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_job_status_exception::de_job_status_exception_xml_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::update_job_status::UpdateJobStatusError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "NotFoundException" => crate::operation::update_job_status::UpdateJobStatusError::NotFoundException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_xml_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::update_job_status::UpdateJobStatusError::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   
        "TooManyRequestsException" => crate::operation::update_job_status::UpdateJobStatusError::TooManyRequestsException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_xml_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::update_job_status::UpdateJobStatusError::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::update_job_status::UpdateJobStatusError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_update_job_status_http_response(
  101     86   
    _response_status: u16,
  102     87   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/sso/src/protocol_serde/shape_get_role_credentials.rs

@@ -3,3 +110,98 @@
   23     23   
        "InvalidRequestException" => crate::operation::get_role_credentials::GetRoleCredentialsError::InvalidRequestException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidRequestExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_request_exception::de_invalid_request_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::get_role_credentials::GetRoleCredentialsError::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   
        "ResourceNotFoundException" => crate::operation::get_role_credentials::GetRoleCredentialsError::ResourceNotFoundException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::get_role_credentials::GetRoleCredentialsError::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   
        "TooManyRequestsException" => crate::operation::get_role_credentials::GetRoleCredentialsError::TooManyRequestsException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::get_role_credentials::GetRoleCredentialsError::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   
        "UnauthorizedException" => crate::operation::get_role_credentials::GetRoleCredentialsError::UnauthorizedException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::UnauthorizedExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_unauthorized_exception::de_unauthorized_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::get_role_credentials::GetRoleCredentialsError::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::get_role_credentials::GetRoleCredentialsError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_get_role_credentials_http_response(
   89     77   
    _response_status: u16,
   90     78   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/sso/src/protocol_serde/shape_list_account_roles.rs

@@ -1,1 +107,95 @@
   20     20   
        "InvalidRequestException" => crate::operation::list_account_roles::ListAccountRolesError::InvalidRequestException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidRequestExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_request_exception::de_invalid_request_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::list_account_roles::ListAccountRolesError::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   
        "ResourceNotFoundException" => crate::operation::list_account_roles::ListAccountRolesError::ResourceNotFoundException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::list_account_roles::ListAccountRolesError::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   
        "TooManyRequestsException" => crate::operation::list_account_roles::ListAccountRolesError::TooManyRequestsException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::list_account_roles::ListAccountRolesError::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   
        "UnauthorizedException" => crate::operation::list_account_roles::ListAccountRolesError::UnauthorizedException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::UnauthorizedExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_unauthorized_exception::de_unauthorized_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::list_account_roles::ListAccountRolesError::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::list_account_roles::ListAccountRolesError::generic(generic),
   81     69   
    })
   82     70   
}
   83     71   
   84     72   
#[allow(clippy::unnecessary_wraps)]
   85     73   
pub fn de_list_account_roles_http_response(
   86     74   
    _response_status: u16,
   87     75   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/sso/src/protocol_serde/shape_list_accounts.rs

@@ -1,1 +107,95 @@
   20     20   
        "InvalidRequestException" => crate::operation::list_accounts::ListAccountsError::InvalidRequestException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidRequestExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_request_exception::de_invalid_request_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::list_accounts::ListAccountsError::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   
        "ResourceNotFoundException" => crate::operation::list_accounts::ListAccountsError::ResourceNotFoundException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::list_accounts::ListAccountsError::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   
        "TooManyRequestsException" => crate::operation::list_accounts::ListAccountsError::TooManyRequestsException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::list_accounts::ListAccountsError::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   
        "UnauthorizedException" => crate::operation::list_accounts::ListAccountsError::UnauthorizedException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::UnauthorizedExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_unauthorized_exception::de_unauthorized_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::list_accounts::ListAccountsError::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::list_accounts::ListAccountsError::generic(generic),
   81     69   
    })
   82     70   
}
   83     71   
   84     72   
#[allow(clippy::unnecessary_wraps)]
   85     73   
pub fn de_list_accounts_http_response(
   86     74   
    _response_status: u16,
   87     75   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/sso/src/protocol_serde/shape_logout.rs

@@ -1,1 +92,83 @@
   20     20   
        "InvalidRequestException" => crate::operation::logout::LogoutError::InvalidRequestException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidRequestExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_request_exception::de_invalid_request_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::logout::LogoutError::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   
        "TooManyRequestsException" => crate::operation::logout::LogoutError::TooManyRequestsException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::logout::LogoutError::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   
        "UnauthorizedException" => crate::operation::logout::LogoutError::UnauthorizedException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::UnauthorizedExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_unauthorized_exception::de_unauthorized_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::logout::LogoutError::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::logout::LogoutError::generic(generic),
   66     57   
    })
   67     58   
}
   68     59   
   69     60   
#[allow(clippy::unnecessary_wraps)]
   70     61   
pub fn de_logout_http_response(
   71     62   
    _response_status: u16,
   72     63   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/protocol_serde/shape_create_token.rs

@@ -1,1 +217,184 @@
   20     20   
        "AccessDeniedException" => crate::operation::create_token::CreateTokenError::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_token::CreateTokenError::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   
        "AuthorizationPendingException" => crate::operation::create_token::CreateTokenError::AuthorizationPendingException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::AuthorizationPendingExceptionBuilder::default();
   40     37   
                output =
   41     38   
                    crate::protocol_serde::shape_authorization_pending_exception::de_authorization_pending_exception_json_err(_response_body, output)
   42     39   
                        .map_err(crate::operation::create_token::CreateTokenError::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   
        "ExpiredTokenException" => crate::operation::create_token::CreateTokenError::ExpiredTokenException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::ExpiredTokenExceptionBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_expired_token_exception::de_expired_token_exception_json_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::create_token::CreateTokenError::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   
        "InternalServerException" => crate::operation::create_token::CreateTokenError::InternalServerException({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::create_token::CreateTokenError::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   
        "InvalidClientException" => crate::operation::create_token::CreateTokenError::InvalidClientException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::InvalidClientExceptionBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_invalid_client_exception::de_invalid_client_exception_json_err(_response_body, output)
   87     75   
                    .map_err(crate::operation::create_token::CreateTokenError::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   
        "InvalidGrantException" => crate::operation::create_token::CreateTokenError::InvalidGrantException({
   97     82   
            #[allow(unused_mut)]
   98     83   
            let mut tmp = {
   99     84   
                #[allow(unused_mut)]
  100     85   
                let mut output = crate::types::error::builders::InvalidGrantExceptionBuilder::default();
  101     86   
                output = crate::protocol_serde::shape_invalid_grant_exception::de_invalid_grant_exception_json_err(_response_body, output)
  102     87   
                    .map_err(crate::operation::create_token::CreateTokenError::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   
        "InvalidRequestException" => crate::operation::create_token::CreateTokenError::InvalidRequestException({
  112     94   
            #[allow(unused_mut)]
  113     95   
            let mut tmp = {
  114     96   
                #[allow(unused_mut)]
  115     97   
                let mut output = crate::types::error::builders::InvalidRequestExceptionBuilder::default();
  116     98   
                output = crate::protocol_serde::shape_invalid_request_exception::de_invalid_request_exception_json_err(_response_body, output)
  117     99   
                    .map_err(crate::operation::create_token::CreateTokenError::unhandled)?;
  118    100   
                let output = output.meta(generic);
  119    101   
                output.build()
  120    102   
            };
  121         -
            if tmp.message.is_none() {
  122         -
                tmp.message = _error_message;
  123         -
            }
  124    103   
            tmp
  125    104   
        }),
  126    105   
        "InvalidScopeException" => crate::operation::create_token::CreateTokenError::InvalidScopeException({
  127    106   
            #[allow(unused_mut)]
  128    107   
            let mut tmp = {
  129    108   
                #[allow(unused_mut)]
  130    109   
                let mut output = crate::types::error::builders::InvalidScopeExceptionBuilder::default();
  131    110   
                output = crate::protocol_serde::shape_invalid_scope_exception::de_invalid_scope_exception_json_err(_response_body, output)
  132    111   
                    .map_err(crate::operation::create_token::CreateTokenError::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   
        "SlowDownException" => crate::operation::create_token::CreateTokenError::SlowDownException({
  142    118   
            #[allow(unused_mut)]
  143    119   
            let mut tmp = {
  144    120   
                #[allow(unused_mut)]
  145    121   
                let mut output = crate::types::error::builders::SlowDownExceptionBuilder::default();
  146    122   
                output = crate::protocol_serde::shape_slow_down_exception::de_slow_down_exception_json_err(_response_body, output)
  147    123   
                    .map_err(crate::operation::create_token::CreateTokenError::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   
        "UnauthorizedClientException" => crate::operation::create_token::CreateTokenError::UnauthorizedClientException({
  157    130   
            #[allow(unused_mut)]
  158    131   
            let mut tmp = {
  159    132   
                #[allow(unused_mut)]
  160    133   
                let mut output = crate::types::error::builders::UnauthorizedClientExceptionBuilder::default();
  161    134   
                output =
  162    135   
                    crate::protocol_serde::shape_unauthorized_client_exception::de_unauthorized_client_exception_json_err(_response_body, output)
  163    136   
                        .map_err(crate::operation::create_token::CreateTokenError::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   
        "UnsupportedGrantTypeException" => crate::operation::create_token::CreateTokenError::UnsupportedGrantTypeException({
  173    143   
            #[allow(unused_mut)]
  174    144   
            let mut tmp = {
  175    145   
                #[allow(unused_mut)]
  176    146   
                let mut output = crate::types::error::builders::UnsupportedGrantTypeExceptionBuilder::default();
  177    147   
                output = crate::protocol_serde::shape_unsupported_grant_type_exception::de_unsupported_grant_type_exception_json_err(
  178    148   
                    _response_body,
  179    149   
                    output,
  180    150   
                )
  181    151   
                .map_err(crate::operation::create_token::CreateTokenError::unhandled)?;
  182    152   
                let output = output.meta(generic);
  183    153   
                output.build()
  184    154   
            };
  185         -
            if tmp.message.is_none() {
  186         -
                tmp.message = _error_message;
  187         -
            }
  188    155   
            tmp
  189    156   
        }),
  190    157   
        _ => crate::operation::create_token::CreateTokenError::generic(generic),
  191    158   
    })
  192    159   
}
  193    160   
  194    161   
#[allow(clippy::unnecessary_wraps)]
  195    162   
pub fn de_create_token_http_response(
  196    163   
    _response_status: u16,
  197    164   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/protocol_serde/shape_create_token_with_iam.rs

@@ -3,3 +238,202 @@
   23     23   
        "AccessDeniedException" => crate::operation::create_token_with_iam::CreateTokenWithIAMError::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::create_token_with_iam::CreateTokenWithIAMError::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   
        "AuthorizationPendingException" => crate::operation::create_token_with_iam::CreateTokenWithIAMError::AuthorizationPendingException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::AuthorizationPendingExceptionBuilder::default();
   43     40   
                output =
   44     41   
                    crate::protocol_serde::shape_authorization_pending_exception::de_authorization_pending_exception_json_err(_response_body, output)
   45     42   
                        .map_err(crate::operation::create_token_with_iam::CreateTokenWithIAMError::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   
        "ExpiredTokenException" => crate::operation::create_token_with_iam::CreateTokenWithIAMError::ExpiredTokenException({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::ExpiredTokenExceptionBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_expired_token_exception::de_expired_token_exception_json_err(_response_body, output)
   60     54   
                    .map_err(crate::operation::create_token_with_iam::CreateTokenWithIAMError::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   
        "InternalServerException" => crate::operation::create_token_with_iam::CreateTokenWithIAMError::InternalServerException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::create_token_with_iam::CreateTokenWithIAMError::unhandled)?;
   76     67   
                let output = output.meta(generic);
   77     68   
                output.build()
   78     69   
            };
   79         -
            if tmp.message.is_none() {
   80         -
                tmp.message = _error_message;
   81         -
            }
   82     70   
            tmp
   83     71   
        }),
   84     72   
        "InvalidClientException" => crate::operation::create_token_with_iam::CreateTokenWithIAMError::InvalidClientException({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::InvalidClientExceptionBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_invalid_client_exception::de_invalid_client_exception_json_err(_response_body, output)
   90     78   
                    .map_err(crate::operation::create_token_with_iam::CreateTokenWithIAMError::unhandled)?;
   91     79   
                let output = output.meta(generic);
   92     80   
                output.build()
   93     81   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     82   
            tmp
   98     83   
        }),
   99     84   
        "InvalidGrantException" => crate::operation::create_token_with_iam::CreateTokenWithIAMError::InvalidGrantException({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::InvalidGrantExceptionBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_invalid_grant_exception::de_invalid_grant_exception_json_err(_response_body, output)
  105     90   
                    .map_err(crate::operation::create_token_with_iam::CreateTokenWithIAMError::unhandled)?;
  106     91   
                let output = output.meta(generic);
  107     92   
                output.build()
  108     93   
            };
  109         -
            if tmp.message.is_none() {
  110         -
                tmp.message = _error_message;
  111         -
            }
  112     94   
            tmp
  113     95   
        }),
  114     96   
        "InvalidRequestException" => crate::operation::create_token_with_iam::CreateTokenWithIAMError::InvalidRequestException({
  115     97   
            #[allow(unused_mut)]
  116     98   
            let mut tmp = {
  117     99   
                #[allow(unused_mut)]
  118    100   
                let mut output = crate::types::error::builders::InvalidRequestExceptionBuilder::default();
  119    101   
                output = crate::protocol_serde::shape_invalid_request_exception::de_invalid_request_exception_json_err(_response_body, output)
  120    102   
                    .map_err(crate::operation::create_token_with_iam::CreateTokenWithIAMError::unhandled)?;
  121    103   
                let output = output.meta(generic);
  122    104   
                output.build()
  123    105   
            };
  124         -
            if tmp.message.is_none() {
  125         -
                tmp.message = _error_message;
  126         -
            }
  127    106   
            tmp
  128    107   
        }),
  129    108   
        "InvalidRequestRegionException" => crate::operation::create_token_with_iam::CreateTokenWithIAMError::InvalidRequestRegionException({
  130    109   
            #[allow(unused_mut)]
  131    110   
            let mut tmp = {
  132    111   
                #[allow(unused_mut)]
  133    112   
                let mut output = crate::types::error::builders::InvalidRequestRegionExceptionBuilder::default();
  134    113   
                output = crate::protocol_serde::shape_invalid_request_region_exception::de_invalid_request_region_exception_json_err(
  135    114   
                    _response_body,
  136    115   
                    output,
  137    116   
                )
  138    117   
                .map_err(crate::operation::create_token_with_iam::CreateTokenWithIAMError::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   
        "InvalidScopeException" => crate::operation::create_token_with_iam::CreateTokenWithIAMError::InvalidScopeException({
  148    124   
            #[allow(unused_mut)]
  149    125   
            let mut tmp = {
  150    126   
                #[allow(unused_mut)]
  151    127   
                let mut output = crate::types::error::builders::InvalidScopeExceptionBuilder::default();
  152    128   
                output = crate::protocol_serde::shape_invalid_scope_exception::de_invalid_scope_exception_json_err(_response_body, output)
  153    129   
                    .map_err(crate::operation::create_token_with_iam::CreateTokenWithIAMError::unhandled)?;
  154    130   
                let output = output.meta(generic);
  155    131   
                output.build()
  156    132   
            };
  157         -
            if tmp.message.is_none() {
  158         -
                tmp.message = _error_message;
  159         -
            }
  160    133   
            tmp
  161    134   
        }),
  162    135   
        "SlowDownException" => crate::operation::create_token_with_iam::CreateTokenWithIAMError::SlowDownException({
  163    136   
            #[allow(unused_mut)]
  164    137   
            let mut tmp = {
  165    138   
                #[allow(unused_mut)]
  166    139   
                let mut output = crate::types::error::builders::SlowDownExceptionBuilder::default();
  167    140   
                output = crate::protocol_serde::shape_slow_down_exception::de_slow_down_exception_json_err(_response_body, output)
  168    141   
                    .map_err(crate::operation::create_token_with_iam::CreateTokenWithIAMError::unhandled)?;
  169    142   
                let output = output.meta(generic);
  170    143   
                output.build()
  171    144   
            };
  172         -
            if tmp.message.is_none() {
  173         -
                tmp.message = _error_message;
  174         -
            }
  175    145   
            tmp
  176    146   
        }),
  177    147   
        "UnauthorizedClientException" => crate::operation::create_token_with_iam::CreateTokenWithIAMError::UnauthorizedClientException({
  178    148   
            #[allow(unused_mut)]
  179    149   
            let mut tmp = {
  180    150   
                #[allow(unused_mut)]
  181    151   
                let mut output = crate::types::error::builders::UnauthorizedClientExceptionBuilder::default();
  182    152   
                output =
  183    153   
                    crate::protocol_serde::shape_unauthorized_client_exception::de_unauthorized_client_exception_json_err(_response_body, output)
  184    154   
                        .map_err(crate::operation::create_token_with_iam::CreateTokenWithIAMError::unhandled)?;
  185    155   
                let output = output.meta(generic);
  186    156   
                output.build()
  187    157   
            };
  188         -
            if tmp.message.is_none() {
  189         -
                tmp.message = _error_message;
  190         -
            }
  191    158   
            tmp
  192    159   
        }),
  193    160   
        "UnsupportedGrantTypeException" => crate::operation::create_token_with_iam::CreateTokenWithIAMError::UnsupportedGrantTypeException({
  194    161   
            #[allow(unused_mut)]
  195    162   
            let mut tmp = {
  196    163   
                #[allow(unused_mut)]
  197    164   
                let mut output = crate::types::error::builders::UnsupportedGrantTypeExceptionBuilder::default();
  198    165   
                output = crate::protocol_serde::shape_unsupported_grant_type_exception::de_unsupported_grant_type_exception_json_err(
  199    166   
                    _response_body,
  200    167   
                    output,
  201    168   
                )
  202    169   
                .map_err(crate::operation::create_token_with_iam::CreateTokenWithIAMError::unhandled)?;
  203    170   
                let output = output.meta(generic);
  204    171   
                output.build()
  205    172   
            };
  206         -
            if tmp.message.is_none() {
  207         -
                tmp.message = _error_message;
  208         -
            }
  209    173   
            tmp
  210    174   
        }),
  211    175   
        _ => crate::operation::create_token_with_iam::CreateTokenWithIAMError::generic(generic),
  212    176   
    })
  213    177   
}
  214    178   
  215    179   
#[allow(clippy::unnecessary_wraps)]
  216    180   
pub fn de_create_token_with_iam_http_response(
  217    181   
    _response_status: u16,
  218    182   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/protocol_serde/shape_register_client.rs

@@ -1,1 +144,126 @@
   20     20   
        "InternalServerException" => crate::operation::register_client::RegisterClientError::InternalServerException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::register_client::RegisterClientError::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   
        "InvalidClientMetadataException" => crate::operation::register_client::RegisterClientError::InvalidClientMetadataException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidClientMetadataExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_client_metadata_exception::de_invalid_client_metadata_exception_json_err(
   41     38   
                    _response_body,
   42     39   
                    output,
   43     40   
                )
   44     41   
                .map_err(crate::operation::register_client::RegisterClientError::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   
        "InvalidRedirectUriException" => crate::operation::register_client::RegisterClientError::InvalidRedirectUriException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidRedirectUriExceptionBuilder::default();
   58     52   
                output =
   59     53   
                    crate::protocol_serde::shape_invalid_redirect_uri_exception::de_invalid_redirect_uri_exception_json_err(_response_body, output)
   60     54   
                        .map_err(crate::operation::register_client::RegisterClientError::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   
        "InvalidRequestException" => crate::operation::register_client::RegisterClientError::InvalidRequestException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::InvalidRequestExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_invalid_request_exception::de_invalid_request_exception_json_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::register_client::RegisterClientError::unhandled)?;
   76     67   
                let output = output.meta(generic);
   77     68   
                output.build()
   78     69   
            };
   79         -
            if tmp.message.is_none() {
   80         -
                tmp.message = _error_message;
   81         -
            }
   82     70   
            tmp
   83     71   
        }),
   84     72   
        "InvalidScopeException" => crate::operation::register_client::RegisterClientError::InvalidScopeException({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::InvalidScopeExceptionBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_invalid_scope_exception::de_invalid_scope_exception_json_err(_response_body, output)
   90     78   
                    .map_err(crate::operation::register_client::RegisterClientError::unhandled)?;
   91     79   
                let output = output.meta(generic);
   92     80   
                output.build()
   93     81   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     82   
            tmp
   98     83   
        }),
   99     84   
        "UnsupportedGrantTypeException" => crate::operation::register_client::RegisterClientError::UnsupportedGrantTypeException({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::UnsupportedGrantTypeExceptionBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_unsupported_grant_type_exception::de_unsupported_grant_type_exception_json_err(
  105     90   
                    _response_body,
  106     91   
                    output,
  107     92   
                )
  108     93   
                .map_err(crate::operation::register_client::RegisterClientError::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   
        _ => crate::operation::register_client::RegisterClientError::generic(generic),
  118    100   
    })
  119    101   
}
  120    102   
  121    103   
#[allow(clippy::unnecessary_wraps)]
  122    104   
pub fn de_register_client_http_response(
  123    105   
    _response_status: u16,
  124    106   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/protocol_serde/shape_start_device_authorization.rs

@@ -7,7 +130,115 @@
   27     27   
        "InternalServerException" => crate::operation::start_device_authorization::StartDeviceAuthorizationError::InternalServerException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::start_device_authorization::StartDeviceAuthorizationError::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   
        "InvalidClientException" => crate::operation::start_device_authorization::StartDeviceAuthorizationError::InvalidClientException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::InvalidClientExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_invalid_client_exception::de_invalid_client_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::start_device_authorization::StartDeviceAuthorizationError::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   
        "InvalidRequestException" => crate::operation::start_device_authorization::StartDeviceAuthorizationError::InvalidRequestException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::InvalidRequestExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_invalid_request_exception::de_invalid_request_exception_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::start_device_authorization::StartDeviceAuthorizationError::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   
        "SlowDownException" => crate::operation::start_device_authorization::StartDeviceAuthorizationError::SlowDownException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::SlowDownExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_slow_down_exception::de_slow_down_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::start_device_authorization::StartDeviceAuthorizationError::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   
        "UnauthorizedClientException" => crate::operation::start_device_authorization::StartDeviceAuthorizationError::UnauthorizedClientException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::UnauthorizedClientExceptionBuilder::default();
   92     80   
                output =
   93     81   
                    crate::protocol_serde::shape_unauthorized_client_exception::de_unauthorized_client_exception_json_err(_response_body, output)
   94     82   
                        .map_err(crate::operation::start_device_authorization::StartDeviceAuthorizationError::unhandled)?;
   95     83   
                let output = output.meta(generic);
   96     84   
                output.build()
   97     85   
            };
   98         -
            if tmp.message.is_none() {
   99         -
                tmp.message = _error_message;
  100         -
            }
  101     86   
            tmp
  102     87   
        }),
  103     88   
        _ => crate::operation::start_device_authorization::StartDeviceAuthorizationError::generic(generic),
  104     89   
    })
  105     90   
}
  106     91   
  107     92   
#[allow(clippy::unnecessary_wraps)]
  108     93   
pub fn de_start_device_authorization_http_response(
  109     94   
    _response_status: u16,
  110     95   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/sts/src/protocol_serde/shape_assume_role.rs

@@ -1,1 +113,101 @@
   20     20   
        "ExpiredTokenException" => crate::operation::assume_role::AssumeRoleError::ExpiredTokenException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ExpiredTokenExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_expired_token_exception::de_expired_token_exception_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::assume_role::AssumeRoleError::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   
        "MalformedPolicyDocument" => crate::operation::assume_role::AssumeRoleError::MalformedPolicyDocumentException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::MalformedPolicyDocumentExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_malformed_policy_document_exception::de_malformed_policy_document_exception_xml_err(
   41     38   
                    _response_body,
   42     39   
                    output,
   43     40   
                )
   44     41   
                .map_err(crate::operation::assume_role::AssumeRoleError::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   
        "PackedPolicyTooLarge" => crate::operation::assume_role::AssumeRoleError::PackedPolicyTooLargeException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::PackedPolicyTooLargeExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_packed_policy_too_large_exception::de_packed_policy_too_large_exception_xml_err(
   59     53   
                    _response_body,
   60     54   
                    output,
   61     55   
                )
   62     56   
                .map_err(crate::operation::assume_role::AssumeRoleError::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   
        "RegionDisabledException" => crate::operation::assume_role::AssumeRoleError::RegionDisabledException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::RegionDisabledExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_region_disabled_exception::de_region_disabled_exception_xml_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::assume_role::AssumeRoleError::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::assume_role::AssumeRoleError::generic(generic),
   87     75   
    })
   88     76   
}
   89     77   
   90     78   
#[allow(clippy::unnecessary_wraps)]
   91     79   
pub fn de_assume_role_http_response(
   92     80   
    _response_status: u16,
   93     81   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/sts/src/protocol_serde/shape_assume_role_with_saml.rs

@@ -3,3 +149,131 @@
   23     23   
        "ExpiredTokenException" => crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError::ExpiredTokenException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ExpiredTokenExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_expired_token_exception::de_expired_token_exception_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError::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   
        "IDPRejectedClaim" => crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError::IdpRejectedClaimException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::IdpRejectedClaimExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_idp_rejected_claim_exception::de_idp_rejected_claim_exception_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError::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   
        "InvalidIdentityToken" => crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError::InvalidIdentityTokenException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidIdentityTokenExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_identity_token_exception::de_invalid_identity_token_exception_xml_err(
   59     53   
                    _response_body,
   60     54   
                    output,
   61     55   
                )
   62     56   
                .map_err(crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError::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   
        "MalformedPolicyDocument" => crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError::MalformedPolicyDocumentException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::MalformedPolicyDocumentExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_malformed_policy_document_exception::de_malformed_policy_document_exception_xml_err(
   77     68   
                    _response_body,
   78     69   
                    output,
   79     70   
                )
   80     71   
                .map_err(crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError::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   
        "PackedPolicyTooLarge" => crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError::PackedPolicyTooLargeException({
   90     78   
            #[allow(unused_mut)]
   91     79   
            let mut tmp = {
   92     80   
                #[allow(unused_mut)]
   93     81   
                let mut output = crate::types::error::builders::PackedPolicyTooLargeExceptionBuilder::default();
   94     82   
                output = crate::protocol_serde::shape_packed_policy_too_large_exception::de_packed_policy_too_large_exception_xml_err(
   95     83   
                    _response_body,
   96     84   
                    output,
   97     85   
                )
   98     86   
                .map_err(crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError::unhandled)?;
   99     87   
                let output = output.meta(generic);
  100     88   
                output.build()
  101     89   
            };
  102         -
            if tmp.message.is_none() {
  103         -
                tmp.message = _error_message;
  104         -
            }
  105     90   
            tmp
  106     91   
        }),
  107     92   
        "RegionDisabledException" => crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError::RegionDisabledException({
  108     93   
            #[allow(unused_mut)]
  109     94   
            let mut tmp = {
  110     95   
                #[allow(unused_mut)]
  111     96   
                let mut output = crate::types::error::builders::RegionDisabledExceptionBuilder::default();
  112     97   
                output = crate::protocol_serde::shape_region_disabled_exception::de_region_disabled_exception_xml_err(_response_body, output)
  113     98   
                    .map_err(crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError::unhandled)?;
  114     99   
                let output = output.meta(generic);
  115    100   
                output.build()
  116    101   
            };
  117         -
            if tmp.message.is_none() {
  118         -
                tmp.message = _error_message;
  119         -
            }
  120    102   
            tmp
  121    103   
        }),
  122    104   
        _ => crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError::generic(generic),
  123    105   
    })
  124    106   
}
  125    107   
  126    108   
#[allow(clippy::unnecessary_wraps)]
  127    109   
pub fn de_assume_role_with_saml_http_response(
  128    110   
    _response_status: u16,
  129    111   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/sts/src/protocol_serde/shape_assume_role_with_web_identity.rs

@@ -3,3 +169,148 @@
   23     23   
        "ExpiredTokenException" => crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::ExpiredTokenException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ExpiredTokenExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_expired_token_exception::de_expired_token_exception_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::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   
        "IDPCommunicationError" => crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::IdpCommunicationErrorException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::IdpCommunicationErrorExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_idp_communication_error_exception::de_idp_communication_error_exception_xml_err(
   44     41   
                    _response_body,
   45     42   
                    output,
   46     43   
                )
   47     44   
                .map_err(crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::unhandled)?;
   48     45   
                let output = output.meta(generic);
   49     46   
                output.build()
   50     47   
            };
   51         -
            if tmp.message.is_none() {
   52         -
                tmp.message = _error_message;
   53         -
            }
   54     48   
            tmp
   55     49   
        }),
   56     50   
        "IDPRejectedClaim" => crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::IdpRejectedClaimException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::IdpRejectedClaimExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_idp_rejected_claim_exception::de_idp_rejected_claim_exception_xml_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::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   
        "InvalidIdentityToken" => crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::InvalidIdentityTokenException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::InvalidIdentityTokenExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_invalid_identity_token_exception::de_invalid_identity_token_exception_xml_err(
   77     68   
                    _response_body,
   78     69   
                    output,
   79     70   
                )
   80     71   
                .map_err(crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::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   
        "MalformedPolicyDocument" => {
   90     78   
            crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::MalformedPolicyDocumentException({
   91     79   
                #[allow(unused_mut)]
   92     80   
                let mut tmp = {
   93     81   
                    #[allow(unused_mut)]
   94     82   
                    let mut output = crate::types::error::builders::MalformedPolicyDocumentExceptionBuilder::default();
   95     83   
                    output = crate::protocol_serde::shape_malformed_policy_document_exception::de_malformed_policy_document_exception_xml_err(
   96     84   
                        _response_body,
   97     85   
                        output,
   98     86   
                    )
   99     87   
                    .map_err(crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::unhandled)?;
  100     88   
                    let output = output.meta(generic);
  101     89   
                    output.build()
  102     90   
                };
  103         -
                if tmp.message.is_none() {
  104         -
                    tmp.message = _error_message;
  105         -
                }
  106     91   
                tmp
  107     92   
            })
  108     93   
        }
  109     94   
        "PackedPolicyTooLarge" => crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::PackedPolicyTooLargeException({
  110     95   
            #[allow(unused_mut)]
  111     96   
            let mut tmp = {
  112     97   
                #[allow(unused_mut)]
  113     98   
                let mut output = crate::types::error::builders::PackedPolicyTooLargeExceptionBuilder::default();
  114     99   
                output = crate::protocol_serde::shape_packed_policy_too_large_exception::de_packed_policy_too_large_exception_xml_err(
  115    100   
                    _response_body,
  116    101   
                    output,
  117    102   
                )
  118    103   
                .map_err(crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::unhandled)?;
  119    104   
                let output = output.meta(generic);
  120    105   
                output.build()
  121    106   
            };
  122         -
            if tmp.message.is_none() {
  123         -
                tmp.message = _error_message;
  124         -
            }
  125    107   
            tmp
  126    108   
        }),
  127    109   
        "RegionDisabledException" => crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::RegionDisabledException({
  128    110   
            #[allow(unused_mut)]
  129    111   
            let mut tmp = {
  130    112   
                #[allow(unused_mut)]
  131    113   
                let mut output = crate::types::error::builders::RegionDisabledExceptionBuilder::default();
  132    114   
                output = crate::protocol_serde::shape_region_disabled_exception::de_region_disabled_exception_xml_err(_response_body, output)
  133    115   
                    .map_err(crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::unhandled)?;
  134    116   
                let output = output.meta(generic);
  135    117   
                output.build()
  136    118   
            };
  137         -
            if tmp.message.is_none() {
  138         -
                tmp.message = _error_message;
  139         -
            }
  140    119   
            tmp
  141    120   
        }),
  142    121   
        _ => crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError::generic(generic),
  143    122   
    })
  144    123   
}
  145    124   
  146    125   
#[allow(clippy::unnecessary_wraps)]
  147    126   
pub fn de_assume_role_with_web_identity_http_response(
  148    127   
    _response_status: u16,
  149    128   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/sts/src/protocol_serde/shape_decode_authorization_message.rs

@@ -8,8 +70,67 @@
   28     28   
                    let mut output = crate::types::error::builders::InvalidAuthorizationMessageExceptionBuilder::default();
   29     29   
                    output =
   30     30   
                        crate::protocol_serde::shape_invalid_authorization_message_exception::de_invalid_authorization_message_exception_xml_err(
   31     31   
                            _response_body,
   32     32   
                            output,
   33     33   
                        )
   34     34   
                        .map_err(crate::operation::decode_authorization_message::DecodeAuthorizationMessageError::unhandled)?;
   35     35   
                    let output = output.meta(generic);
   36     36   
                    output.build()
   37     37   
                };
   38         -
                if tmp.message.is_none() {
   39         -
                    tmp.message = _error_message;
   40         -
                }
   41     38   
                tmp
   42     39   
            })
   43     40   
        }
   44     41   
        _ => crate::operation::decode_authorization_message::DecodeAuthorizationMessageError::generic(generic),
   45     42   
    })
   46     43   
}
   47     44   
   48     45   
#[allow(clippy::unnecessary_wraps)]
   49     46   
pub fn de_decode_authorization_message_http_response(
   50     47   
    _response_status: u16,