AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df

Files changed:

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

@@ -6,6 +101,92 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::MalformedPolicyDocumentExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_malformed_policy_document_exception::de_malformed_policy_document_exception_xml_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::get_federation_token::GetFederationTokenError::unhandled)?;
   33     33   
                let output = output.meta(generic);
   34     34   
                output.build()
   35     35   
            };
   36         -
            if tmp.message.is_none() {
   37         -
                tmp.message = _error_message;
   38         -
            }
   39     36   
            tmp
   40     37   
        }),
   41     38   
        "PackedPolicyTooLarge" => crate::operation::get_federation_token::GetFederationTokenError::PackedPolicyTooLargeException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::PackedPolicyTooLargeExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_packed_policy_too_large_exception::de_packed_policy_too_large_exception_xml_err(
   47     44   
                    _response_body,
   48     45   
                    output,
   49     46   
                )
   50     47   
                .map_err(crate::operation::get_federation_token::GetFederationTokenError::unhandled)?;
   51     48   
                let output = output.meta(generic);
   52     49   
                output.build()
   53     50   
            };
   54         -
            if tmp.message.is_none() {
   55         -
                tmp.message = _error_message;
   56         -
            }
   57     51   
            tmp
   58     52   
        }),
   59     53   
        "RegionDisabledException" => crate::operation::get_federation_token::GetFederationTokenError::RegionDisabledException({
   60     54   
            #[allow(unused_mut)]
   61     55   
            let mut tmp = {
   62     56   
                #[allow(unused_mut)]
   63     57   
                let mut output = crate::types::error::builders::RegionDisabledExceptionBuilder::default();
   64     58   
                output = crate::protocol_serde::shape_region_disabled_exception::de_region_disabled_exception_xml_err(_response_body, output)
   65     59   
                    .map_err(crate::operation::get_federation_token::GetFederationTokenError::unhandled)?;
   66     60   
                let output = output.meta(generic);
   67     61   
                output.build()
   68     62   
            };
   69         -
            if tmp.message.is_none() {
   70         -
                tmp.message = _error_message;
   71         -
            }
   72     63   
            tmp
   73     64   
        }),
   74     65   
        _ => crate::operation::get_federation_token::GetFederationTokenError::generic(generic),
   75     66   
    })
   76     67   
}
   77     68   
   78     69   
#[allow(clippy::unnecessary_wraps)]
   79     70   
pub fn de_get_federation_token_http_response(
   80     71   
    _response_status: u16,
   81     72   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +62,59 @@
   20     20   
        "RegionDisabledException" => crate::operation::get_session_token::GetSessionTokenError::RegionDisabledException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::RegionDisabledExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_region_disabled_exception::de_region_disabled_exception_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::get_session_token::GetSessionTokenError::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   
        _ => crate::operation::get_session_token::GetSessionTokenError::generic(generic),
   36     33   
    })
   37     34   
}
   38     35   
   39     36   
#[allow(clippy::unnecessary_wraps)]
   40     37   
pub fn de_get_session_token_http_response(
   41     38   
    _response_status: u16,
   42     39   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/protocol_serde/shape_cancel_query.rs

@@ -1,1 +122,107 @@
   20     20   
        "AccessDeniedException" => crate::operation::cancel_query::CancelQueryError::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::cancel_query::CancelQueryError::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   
        "InternalServerException" => crate::operation::cancel_query::CancelQueryError::InternalServerException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::cancel_query::CancelQueryError::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   
        "InvalidEndpointException" => crate::operation::cancel_query::CancelQueryError::InvalidEndpointException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::cancel_query::CancelQueryError::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   
        "ThrottlingException" => crate::operation::cancel_query::CancelQueryError::ThrottlingException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::cancel_query::CancelQueryError::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   
        "ValidationException" => crate::operation::cancel_query::CancelQueryError::ValidationException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::cancel_query::CancelQueryError::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::cancel_query::CancelQueryError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_cancel_query_http_response(
  101     86   
    _response_status: u16,
  102     87   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/protocol_serde/shape_create_scheduled_query.rs

@@ -3,3 +158,137 @@
   23     23   
        "AccessDeniedException" => crate::operation::create_scheduled_query::CreateScheduledQueryError::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_scheduled_query::CreateScheduledQueryError::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   
        "ConflictException" => crate::operation::create_scheduled_query::CreateScheduledQueryError::ConflictException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::create_scheduled_query::CreateScheduledQueryError::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   
        "InternalServerException" => crate::operation::create_scheduled_query::CreateScheduledQueryError::InternalServerException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::create_scheduled_query::CreateScheduledQueryError::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   
        "InvalidEndpointException" => crate::operation::create_scheduled_query::CreateScheduledQueryError::InvalidEndpointException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::create_scheduled_query::CreateScheduledQueryError::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   
        "ServiceQuotaExceededException" => crate::operation::create_scheduled_query::CreateScheduledQueryError::ServiceQuotaExceededException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
   89     77   
                    _response_body,
   90     78   
                    output,
   91     79   
                )
   92     80   
                .map_err(crate::operation::create_scheduled_query::CreateScheduledQueryError::unhandled)?;
   93     81   
                let output = output.meta(generic);
   94     82   
                output.build()
   95     83   
            };
   96         -
            if tmp.message.is_none() {
   97         -
                tmp.message = _error_message;
   98         -
            }
   99     84   
            tmp
  100     85   
        }),
  101     86   
        "ThrottlingException" => crate::operation::create_scheduled_query::CreateScheduledQueryError::ThrottlingException({
  102     87   
            #[allow(unused_mut)]
  103     88   
            let mut tmp = {
  104     89   
                #[allow(unused_mut)]
  105     90   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
  106     91   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
  107     92   
                    .map_err(crate::operation::create_scheduled_query::CreateScheduledQueryError::unhandled)?;
  108     93   
                let output = output.meta(generic);
  109     94   
                output.build()
  110     95   
            };
  111         -
            if tmp.message.is_none() {
  112         -
                tmp.message = _error_message;
  113         -
            }
  114     96   
            tmp
  115     97   
        }),
  116     98   
        "ValidationException" => crate::operation::create_scheduled_query::CreateScheduledQueryError::ValidationException({
  117     99   
            #[allow(unused_mut)]
  118    100   
            let mut tmp = {
  119    101   
                #[allow(unused_mut)]
  120    102   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
  121    103   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  122    104   
                    .map_err(crate::operation::create_scheduled_query::CreateScheduledQueryError::unhandled)?;
  123    105   
                let output = output.meta(generic);
  124    106   
                output.build()
  125    107   
            };
  126         -
            if tmp.message.is_none() {
  127         -
                tmp.message = _error_message;
  128         -
            }
  129    108   
            tmp
  130    109   
        }),
  131    110   
        _ => crate::operation::create_scheduled_query::CreateScheduledQueryError::generic(generic),
  132    111   
    })
  133    112   
}
  134    113   
  135    114   
#[allow(clippy::unnecessary_wraps)]
  136    115   
pub fn de_create_scheduled_query_http_response(
  137    116   
    _response_status: u16,
  138    117   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/protocol_serde/shape_delete_scheduled_query.rs

@@ -3,3 +140,122 @@
   23     23   
        "AccessDeniedException" => crate::operation::delete_scheduled_query::DeleteScheduledQueryError::AccessDeniedException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::delete_scheduled_query::DeleteScheduledQueryError::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   
        "InternalServerException" => crate::operation::delete_scheduled_query::DeleteScheduledQueryError::InternalServerException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::delete_scheduled_query::DeleteScheduledQueryError::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   
        "InvalidEndpointException" => crate::operation::delete_scheduled_query::DeleteScheduledQueryError::InvalidEndpointException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::delete_scheduled_query::DeleteScheduledQueryError::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   
        "ResourceNotFoundException" => crate::operation::delete_scheduled_query::DeleteScheduledQueryError::ResourceNotFoundException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::delete_scheduled_query::DeleteScheduledQueryError::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   
        "ThrottlingException" => crate::operation::delete_scheduled_query::DeleteScheduledQueryError::ThrottlingException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::delete_scheduled_query::DeleteScheduledQueryError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        "ValidationException" => crate::operation::delete_scheduled_query::DeleteScheduledQueryError::ValidationException({
   99     84   
            #[allow(unused_mut)]
  100     85   
            let mut tmp = {
  101     86   
                #[allow(unused_mut)]
  102     87   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
  103     88   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  104     89   
                    .map_err(crate::operation::delete_scheduled_query::DeleteScheduledQueryError::unhandled)?;
  105     90   
                let output = output.meta(generic);
  106     91   
                output.build()
  107     92   
            };
  108         -
            if tmp.message.is_none() {
  109         -
                tmp.message = _error_message;
  110         -
            }
  111     93   
            tmp
  112     94   
        }),
  113     95   
        _ => crate::operation::delete_scheduled_query::DeleteScheduledQueryError::generic(generic),
  114     96   
    })
  115     97   
}
  116     98   
  117     99   
#[allow(clippy::unnecessary_wraps)]
  118    100   
pub fn de_delete_scheduled_query_http_response(
  119    101   
    _response_status: u16,
  120    102   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/protocol_serde/shape_describe_account_settings.rs

@@ -7,7 +114,102 @@
   27     27   
        "AccessDeniedException" => crate::operation::describe_account_settings::DescribeAccountSettingsError::AccessDeniedException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::describe_account_settings::DescribeAccountSettingsError::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   
        "InternalServerException" => crate::operation::describe_account_settings::DescribeAccountSettingsError::InternalServerException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::describe_account_settings::DescribeAccountSettingsError::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   
        "InvalidEndpointException" => crate::operation::describe_account_settings::DescribeAccountSettingsError::InvalidEndpointException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::describe_account_settings::DescribeAccountSettingsError::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   
        "ThrottlingException" => crate::operation::describe_account_settings::DescribeAccountSettingsError::ThrottlingException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::describe_account_settings::DescribeAccountSettingsError::unhandled)?;
   79     70   
                let output = output.meta(generic);
   80     71   
                output.build()
   81     72   
            };
   82         -
            if tmp.message.is_none() {
   83         -
                tmp.message = _error_message;
   84         -
            }
   85     73   
            tmp
   86     74   
        }),
   87     75   
        _ => crate::operation::describe_account_settings::DescribeAccountSettingsError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_describe_account_settings_http_response(
   93     81   
    _response_status: u16,
   94     82   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/protocol_serde/shape_describe_endpoints.rs

@@ -1,1 +93,84 @@
   21     21   
        "InternalServerException" => crate::operation::describe_endpoints::DescribeEndpointsError::InternalServerException({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::describe_endpoints::DescribeEndpointsError::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   
        "ThrottlingException" => crate::operation::describe_endpoints::DescribeEndpointsError::ThrottlingException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::describe_endpoints::DescribeEndpointsError::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   
        "ValidationException" => crate::operation::describe_endpoints::DescribeEndpointsError::ValidationException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::describe_endpoints::DescribeEndpointsError::unhandled)?;
   58     52   
                let output = output.meta(generic);
   59     53   
                output.build()
   60     54   
            };
   61         -
            if tmp.message.is_none() {
   62         -
                tmp.message = _error_message;
   63         -
            }
   64     55   
            tmp
   65     56   
        }),
   66     57   
        _ => crate::operation::describe_endpoints::DescribeEndpointsError::generic(generic),
   67     58   
    })
   68     59   
}
   69     60   
   70     61   
#[allow(clippy::unnecessary_wraps)]
   71     62   
pub fn de_describe_endpoints_http_response(
   72     63   
    _response_status: u16,
   73     64   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/protocol_serde/shape_describe_scheduled_query.rs

@@ -7,7 +144,126 @@
   27     27   
        "AccessDeniedException" => crate::operation::describe_scheduled_query::DescribeScheduledQueryError::AccessDeniedException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::describe_scheduled_query::DescribeScheduledQueryError::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   
        "InternalServerException" => crate::operation::describe_scheduled_query::DescribeScheduledQueryError::InternalServerException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::describe_scheduled_query::DescribeScheduledQueryError::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   
        "InvalidEndpointException" => crate::operation::describe_scheduled_query::DescribeScheduledQueryError::InvalidEndpointException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::describe_scheduled_query::DescribeScheduledQueryError::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   
        "ResourceNotFoundException" => crate::operation::describe_scheduled_query::DescribeScheduledQueryError::ResourceNotFoundException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::describe_scheduled_query::DescribeScheduledQueryError::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   
        "ThrottlingException" => crate::operation::describe_scheduled_query::DescribeScheduledQueryError::ThrottlingException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::describe_scheduled_query::DescribeScheduledQueryError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        "ValidationException" => crate::operation::describe_scheduled_query::DescribeScheduledQueryError::ValidationException({
  103     88   
            #[allow(unused_mut)]
  104     89   
            let mut tmp = {
  105     90   
                #[allow(unused_mut)]
  106     91   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
  107     92   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  108     93   
                    .map_err(crate::operation::describe_scheduled_query::DescribeScheduledQueryError::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::describe_scheduled_query::DescribeScheduledQueryError::generic(generic),
  118    100   
    })
  119    101   
}
  120    102   
  121    103   
#[allow(clippy::unnecessary_wraps)]
  122    104   
pub fn de_describe_scheduled_query_http_response(
  123    105   
    _response_status: u16,
  124    106   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/protocol_serde/shape_execute_scheduled_query.rs

@@ -3,3 +140,122 @@
   23     23   
        "AccessDeniedException" => crate::operation::execute_scheduled_query::ExecuteScheduledQueryError::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::execute_scheduled_query::ExecuteScheduledQueryError::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   
        "InternalServerException" => crate::operation::execute_scheduled_query::ExecuteScheduledQueryError::InternalServerException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::execute_scheduled_query::ExecuteScheduledQueryError::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   
        "InvalidEndpointException" => crate::operation::execute_scheduled_query::ExecuteScheduledQueryError::InvalidEndpointException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::execute_scheduled_query::ExecuteScheduledQueryError::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   
        "ResourceNotFoundException" => crate::operation::execute_scheduled_query::ExecuteScheduledQueryError::ResourceNotFoundException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::execute_scheduled_query::ExecuteScheduledQueryError::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   
        "ThrottlingException" => crate::operation::execute_scheduled_query::ExecuteScheduledQueryError::ThrottlingException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::execute_scheduled_query::ExecuteScheduledQueryError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        "ValidationException" => crate::operation::execute_scheduled_query::ExecuteScheduledQueryError::ValidationException({
   99     84   
            #[allow(unused_mut)]
  100     85   
            let mut tmp = {
  101     86   
                #[allow(unused_mut)]
  102     87   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
  103     88   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  104     89   
                    .map_err(crate::operation::execute_scheduled_query::ExecuteScheduledQueryError::unhandled)?;
  105     90   
                let output = output.meta(generic);
  106     91   
                output.build()
  107     92   
            };
  108         -
            if tmp.message.is_none() {
  109         -
                tmp.message = _error_message;
  110         -
            }
  111     93   
            tmp
  112     94   
        }),
  113     95   
        _ => crate::operation::execute_scheduled_query::ExecuteScheduledQueryError::generic(generic),
  114     96   
    })
  115     97   
}
  116     98   
  117     99   
#[allow(clippy::unnecessary_wraps)]
  118    100   
pub fn de_execute_scheduled_query_http_response(
  119    101   
    _response_status: u16,
  120    102   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/protocol_serde/shape_list_scheduled_queries.rs

@@ -3,3 +125,110 @@
   23     23   
        "AccessDeniedException" => crate::operation::list_scheduled_queries::ListScheduledQueriesError::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::list_scheduled_queries::ListScheduledQueriesError::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   
        "InternalServerException" => crate::operation::list_scheduled_queries::ListScheduledQueriesError::InternalServerException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::list_scheduled_queries::ListScheduledQueriesError::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   
        "InvalidEndpointException" => crate::operation::list_scheduled_queries::ListScheduledQueriesError::InvalidEndpointException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::list_scheduled_queries::ListScheduledQueriesError::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   
        "ThrottlingException" => crate::operation::list_scheduled_queries::ListScheduledQueriesError::ThrottlingException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::list_scheduled_queries::ListScheduledQueriesError::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   
        "ValidationException" => crate::operation::list_scheduled_queries::ListScheduledQueriesError::ValidationException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::list_scheduled_queries::ListScheduledQueriesError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        _ => crate::operation::list_scheduled_queries::ListScheduledQueriesError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_list_scheduled_queries_http_response(
  104     89   
    _response_status: u16,
  105     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +110,98 @@
   23     23   
        "InvalidEndpointException" => crate::operation::list_tags_for_resource::ListTagsForResourceError::InvalidEndpointException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::list_tags_for_resource::ListTagsForResourceError::unhandled)?;
   30     30   
                let output = output.meta(generic);
   31     31   
                output.build()
   32     32   
            };
   33         -
            if tmp.message.is_none() {
   34         -
                tmp.message = _error_message;
   35         -
            }
   36     33   
            tmp
   37     34   
        }),
   38     35   
        "ResourceNotFoundException" => crate::operation::list_tags_for_resource::ListTagsForResourceError::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::list_tags_for_resource::ListTagsForResourceError::unhandled)?;
   45     42   
                let output = output.meta(generic);
   46     43   
                output.build()
   47     44   
            };
   48         -
            if tmp.message.is_none() {
   49         -
                tmp.message = _error_message;
   50         -
            }
   51     45   
            tmp
   52     46   
        }),
   53     47   
        "ThrottlingException" => crate::operation::list_tags_for_resource::ListTagsForResourceError::ThrottlingException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::list_tags_for_resource::ListTagsForResourceError::unhandled)?;
   60     54   
                let output = output.meta(generic);
   61     55   
                output.build()
   62     56   
            };
   63         -
            if tmp.message.is_none() {
   64         -
                tmp.message = _error_message;
   65         -
            }
   66     57   
            tmp
   67     58   
        }),
   68     59   
        "ValidationException" => crate::operation::list_tags_for_resource::ListTagsForResourceError::ValidationException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::list_tags_for_resource::ListTagsForResourceError::unhandled)?;
   75     66   
                let output = output.meta(generic);
   76     67   
                output.build()
   77     68   
            };
   78         -
            if tmp.message.is_none() {
   79         -
                tmp.message = _error_message;
   80         -
            }
   81     69   
            tmp
   82     70   
        }),
   83     71   
        _ => crate::operation::list_tags_for_resource::ListTagsForResourceError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_list_tags_for_resource_http_response(
   89     77   
    _response_status: u16,
   90     78   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/protocol_serde/shape_prepare_query.rs

@@ -1,1 +122,107 @@
   20     20   
        "AccessDeniedException" => crate::operation::prepare_query::PrepareQueryError::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::prepare_query::PrepareQueryError::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   
        "InternalServerException" => crate::operation::prepare_query::PrepareQueryError::InternalServerException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::prepare_query::PrepareQueryError::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   
        "InvalidEndpointException" => crate::operation::prepare_query::PrepareQueryError::InvalidEndpointException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::prepare_query::PrepareQueryError::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   
        "ThrottlingException" => crate::operation::prepare_query::PrepareQueryError::ThrottlingException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::prepare_query::PrepareQueryError::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   
        "ValidationException" => crate::operation::prepare_query::PrepareQueryError::ValidationException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::prepare_query::PrepareQueryError::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::prepare_query::PrepareQueryError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_prepare_query_http_response(
  101     86   
    _response_status: u16,
  102     87   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/protocol_serde/shape_query.rs

@@ -1,1 +152,131 @@
   20     20   
        "AccessDeniedException" => crate::operation::query::QueryError::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::query::QueryError::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   
        "ConflictException" => crate::operation::query::QueryError::ConflictException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::query::QueryError::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   
        "InternalServerException" => crate::operation::query::QueryError::InternalServerException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::query::QueryError::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   
        "InvalidEndpointException" => crate::operation::query::QueryError::InvalidEndpointException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::query::QueryError::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   
        "QueryExecutionException" => crate::operation::query::QueryError::QueryExecutionException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::QueryExecutionExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_query_execution_exception::de_query_execution_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::query::QueryError::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   
        "ThrottlingException" => crate::operation::query::QueryError::ThrottlingException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
  100     85   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
  101     86   
                    .map_err(crate::operation::query::QueryError::unhandled)?;
  102     87   
                let output = output.meta(generic);
  103     88   
                output.build()
  104     89   
            };
  105         -
            if tmp.message.is_none() {
  106         -
                tmp.message = _error_message;
  107         -
            }
  108     90   
            tmp
  109     91   
        }),
  110     92   
        "ValidationException" => crate::operation::query::QueryError::ValidationException({
  111     93   
            #[allow(unused_mut)]
  112     94   
            let mut tmp = {
  113     95   
                #[allow(unused_mut)]
  114     96   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
  115     97   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  116     98   
                    .map_err(crate::operation::query::QueryError::unhandled)?;
  117     99   
                let output = output.meta(generic);
  118    100   
                output.build()
  119    101   
            };
  120         -
            if tmp.message.is_none() {
  121         -
                tmp.message = _error_message;
  122         -
            }
  123    102   
            tmp
  124    103   
        }),
  125    104   
        _ => crate::operation::query::QueryError::generic(generic),
  126    105   
    })
  127    106   
}
  128    107   
  129    108   
#[allow(clippy::unnecessary_wraps)]
  130    109   
pub fn de_query_http_response(
  131    110   
    _response_status: u16,
  132    111   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +124,109 @@
   20     20   
        "InvalidEndpointException" => crate::operation::tag_resource::TagResourceError::InvalidEndpointException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::tag_resource::TagResourceError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "ResourceNotFoundException" => crate::operation::tag_resource::TagResourceError::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::tag_resource::TagResourceError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "ServiceQuotaExceededException" => crate::operation::tag_resource::TagResourceError::ServiceQuotaExceededException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
   56     50   
                    _response_body,
   57     51   
                    output,
   58     52   
                )
   59     53   
                .map_err(crate::operation::tag_resource::TagResourceError::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   
        "ThrottlingException" => crate::operation::tag_resource::TagResourceError::ThrottlingException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::tag_resource::TagResourceError::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   
        "ValidationException" => crate::operation::tag_resource::TagResourceError::ValidationException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::tag_resource::TagResourceError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        _ => crate::operation::tag_resource::TagResourceError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_tag_resource_http_response(
  104     89   
    _response_status: u16,
  105     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +106,94 @@
   20     20   
        "InvalidEndpointException" => crate::operation::untag_resource::UntagResourceError::InvalidEndpointException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::untag_resource::UntagResourceError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "ResourceNotFoundException" => crate::operation::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "ThrottlingException" => crate::operation::untag_resource::UntagResourceError::ThrottlingException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::untag_resource::UntagResourceError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "ValidationException" => crate::operation::untag_resource::UntagResourceError::ValidationException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::untag_resource::UntagResourceError::unhandled)?;
   72     63   
                let output = output.meta(generic);
   73     64   
                output.build()
   74     65   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     66   
            tmp
   79     67   
        }),
   80     68   
        _ => crate::operation::untag_resource::UntagResourceError::generic(generic),
   81     69   
    })
   82     70   
}
   83     71   
   84     72   
#[allow(clippy::unnecessary_wraps)]
   85     73   
pub fn de_untag_resource_http_response(
   86     74   
    _response_status: u16,
   87     75   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/protocol_serde/shape_update_account_settings.rs

@@ -3,3 +125,110 @@
   23     23   
        "AccessDeniedException" => crate::operation::update_account_settings::UpdateAccountSettingsError::AccessDeniedException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::update_account_settings::UpdateAccountSettingsError::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   
        "InternalServerException" => crate::operation::update_account_settings::UpdateAccountSettingsError::InternalServerException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::update_account_settings::UpdateAccountSettingsError::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   
        "InvalidEndpointException" => crate::operation::update_account_settings::UpdateAccountSettingsError::InvalidEndpointException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::update_account_settings::UpdateAccountSettingsError::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   
        "ThrottlingException" => crate::operation::update_account_settings::UpdateAccountSettingsError::ThrottlingException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::update_account_settings::UpdateAccountSettingsError::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   
        "ValidationException" => crate::operation::update_account_settings::UpdateAccountSettingsError::ValidationException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::update_account_settings::UpdateAccountSettingsError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        _ => crate::operation::update_account_settings::UpdateAccountSettingsError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_update_account_settings_http_response(
  104     89   
    _response_status: u16,
  105     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,