AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05

Files changed:

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

@@ -3,3 +140,122 @@
   23     23   
        "AccessDeniedException" => crate::operation::update_scheduled_query::UpdateScheduledQueryError::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_scheduled_query::UpdateScheduledQueryError::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_scheduled_query::UpdateScheduledQueryError::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_scheduled_query::UpdateScheduledQueryError::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_scheduled_query::UpdateScheduledQueryError::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_scheduled_query::UpdateScheduledQueryError::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::update_scheduled_query::UpdateScheduledQueryError::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::update_scheduled_query::UpdateScheduledQueryError::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::update_scheduled_query::UpdateScheduledQueryError::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::update_scheduled_query::UpdateScheduledQueryError::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::update_scheduled_query::UpdateScheduledQueryError::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::update_scheduled_query::UpdateScheduledQueryError::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::update_scheduled_query::UpdateScheduledQueryError::generic(generic),
  114     96   
    })
  115     97   
}
  116     98   
  117     99   
#[allow(clippy::unnecessary_wraps)]
  118    100   
pub fn de_update_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/timestreamwrite/src/protocol_serde/shape_create_batch_load_task.rs

@@ -45,45 +140,131 @@
   65     65   
        "InvalidEndpointException" => crate::operation::create_batch_load_task::CreateBatchLoadTaskError::InvalidEndpointException({
   66     66   
            #[allow(unused_mut)]
   67     67   
            let mut tmp = {
   68     68   
                #[allow(unused_mut)]
   69     69   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   70     70   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   71     71   
                    .map_err(crate::operation::create_batch_load_task::CreateBatchLoadTaskError::unhandled)?;
   72     72   
                let output = output.meta(generic);
   73     73   
                output.build()
   74     74   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     75   
            tmp
   79     76   
        }),
   80     77   
        "ResourceNotFoundException" => crate::operation::create_batch_load_task::CreateBatchLoadTaskError::ResourceNotFoundException({
   81     78   
            #[allow(unused_mut)]
   82     79   
            let mut tmp = {
   83     80   
                #[allow(unused_mut)]
   84     81   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   85     82   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   86     83   
                    .map_err(crate::operation::create_batch_load_task::CreateBatchLoadTaskError::unhandled)?;
   87     84   
                let output = output.meta(generic);
   88     85   
                output.build()
   89     86   
            };
   90         -
            if tmp.message.is_none() {
   91         -
                tmp.message = _error_message;
   92         -
            }
   93     87   
            tmp
   94     88   
        }),
   95     89   
        "ServiceQuotaExceededException" => crate::operation::create_batch_load_task::CreateBatchLoadTaskError::ServiceQuotaExceededException({
   96     90   
            #[allow(unused_mut)]
   97     91   
            let mut tmp = {
   98     92   
                #[allow(unused_mut)]
   99     93   
                let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
  100     94   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
  101     95   
                    _response_body,
  102     96   
                    output,
  103     97   
                )
  104     98   
                .map_err(crate::operation::create_batch_load_task::CreateBatchLoadTaskError::unhandled)?;
  105     99   
                let output = output.meta(generic);
  106    100   
                output.build()
  107    101   
            };
  108         -
            if tmp.message.is_none() {
  109         -
                tmp.message = _error_message;
  110         -
            }
  111    102   
            tmp
  112    103   
        }),
  113    104   
        "ThrottlingException" => crate::operation::create_batch_load_task::CreateBatchLoadTaskError::ThrottlingException({
  114    105   
            #[allow(unused_mut)]
  115    106   
            let mut tmp = {
  116    107   
                #[allow(unused_mut)]
  117    108   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
  118    109   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
  119    110   
                    .map_err(crate::operation::create_batch_load_task::CreateBatchLoadTaskError::unhandled)?;
  120    111   
                let output = output.meta(generic);

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_create_database.rs

@@ -42,42 +122,116 @@
   62     62   
        "InvalidEndpointException" => crate::operation::create_database::CreateDatabaseError::InvalidEndpointException({
   63     63   
            #[allow(unused_mut)]
   64     64   
            let mut tmp = {
   65     65   
                #[allow(unused_mut)]
   66     66   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   67     67   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   68     68   
                    .map_err(crate::operation::create_database::CreateDatabaseError::unhandled)?;
   69     69   
                let output = output.meta(generic);
   70     70   
                output.build()
   71     71   
            };
   72         -
            if tmp.message.is_none() {
   73         -
                tmp.message = _error_message;
   74         -
            }
   75     72   
            tmp
   76     73   
        }),
   77     74   
        "ServiceQuotaExceededException" => crate::operation::create_database::CreateDatabaseError::ServiceQuotaExceededException({
   78     75   
            #[allow(unused_mut)]
   79     76   
            let mut tmp = {
   80     77   
                #[allow(unused_mut)]
   81     78   
                let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
   82     79   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
   83     80   
                    _response_body,
   84     81   
                    output,
   85     82   
                )
   86     83   
                .map_err(crate::operation::create_database::CreateDatabaseError::unhandled)?;
   87     84   
                let output = output.meta(generic);
   88     85   
                output.build()
   89     86   
            };
   90         -
            if tmp.message.is_none() {
   91         -
                tmp.message = _error_message;
   92         -
            }
   93     87   
            tmp
   94     88   
        }),
   95     89   
        "ThrottlingException" => crate::operation::create_database::CreateDatabaseError::ThrottlingException({
   96     90   
            #[allow(unused_mut)]
   97     91   
            let mut tmp = {
   98     92   
                #[allow(unused_mut)]
   99     93   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
  100     94   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
  101     95   
                    .map_err(crate::operation::create_database::CreateDatabaseError::unhandled)?;
  102     96   
                let output = output.meta(generic);

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_create_table.rs

@@ -42,42 +137,128 @@
   62     62   
        "InvalidEndpointException" => crate::operation::create_table::CreateTableError::InvalidEndpointException({
   63     63   
            #[allow(unused_mut)]
   64     64   
            let mut tmp = {
   65     65   
                #[allow(unused_mut)]
   66     66   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   67     67   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   68     68   
                    .map_err(crate::operation::create_table::CreateTableError::unhandled)?;
   69     69   
                let output = output.meta(generic);
   70     70   
                output.build()
   71     71   
            };
   72         -
            if tmp.message.is_none() {
   73         -
                tmp.message = _error_message;
   74         -
            }
   75     72   
            tmp
   76     73   
        }),
   77     74   
        "ResourceNotFoundException" => crate::operation::create_table::CreateTableError::ResourceNotFoundException({
   78     75   
            #[allow(unused_mut)]
   79     76   
            let mut tmp = {
   80     77   
                #[allow(unused_mut)]
   81     78   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   82     79   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   83     80   
                    .map_err(crate::operation::create_table::CreateTableError::unhandled)?;
   84     81   
                let output = output.meta(generic);
   85     82   
                output.build()
   86     83   
            };
   87         -
            if tmp.message.is_none() {
   88         -
                tmp.message = _error_message;
   89         -
            }
   90     84   
            tmp
   91     85   
        }),
   92     86   
        "ServiceQuotaExceededException" => crate::operation::create_table::CreateTableError::ServiceQuotaExceededException({
   93     87   
            #[allow(unused_mut)]
   94     88   
            let mut tmp = {
   95     89   
                #[allow(unused_mut)]
   96     90   
                let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
   97     91   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
   98     92   
                    _response_body,
   99     93   
                    output,
  100     94   
                )
  101     95   
                .map_err(crate::operation::create_table::CreateTableError::unhandled)?;
  102     96   
                let output = output.meta(generic);
  103     97   
                output.build()
  104     98   
            };
  105         -
            if tmp.message.is_none() {
  106         -
                tmp.message = _error_message;
  107         -
            }
  108     99   
            tmp
  109    100   
        }),
  110    101   
        "ThrottlingException" => crate::operation::create_table::CreateTableError::ThrottlingException({
  111    102   
            #[allow(unused_mut)]
  112    103   
            let mut tmp = {
  113    104   
                #[allow(unused_mut)]
  114    105   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
  115    106   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
  116    107   
                    .map_err(crate::operation::create_table::CreateTableError::unhandled)?;
  117    108   
                let output = output.meta(generic);

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_delete_database.rs

@@ -28,28 +105,99 @@
   48     48   
        "InvalidEndpointException" => crate::operation::delete_database::DeleteDatabaseError::InvalidEndpointException({
   49     49   
            #[allow(unused_mut)]
   50     50   
            let mut tmp = {
   51     51   
                #[allow(unused_mut)]
   52     52   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   53     53   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   54     54   
                    .map_err(crate::operation::delete_database::DeleteDatabaseError::unhandled)?;
   55     55   
                let output = output.meta(generic);
   56     56   
                output.build()
   57     57   
            };
   58         -
            if tmp.message.is_none() {
   59         -
                tmp.message = _error_message;
   60         -
            }
   61     58   
            tmp
   62     59   
        }),
   63     60   
        "ResourceNotFoundException" => crate::operation::delete_database::DeleteDatabaseError::ResourceNotFoundException({
   64     61   
            #[allow(unused_mut)]
   65     62   
            let mut tmp = {
   66     63   
                #[allow(unused_mut)]
   67     64   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   68     65   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   69     66   
                    .map_err(crate::operation::delete_database::DeleteDatabaseError::unhandled)?;
   70     67   
                let output = output.meta(generic);
   71     68   
                output.build()
   72     69   
            };
   73         -
            if tmp.message.is_none() {
   74         -
                tmp.message = _error_message;
   75         -
            }
   76     70   
            tmp
   77     71   
        }),
   78     72   
        "ThrottlingException" => crate::operation::delete_database::DeleteDatabaseError::ThrottlingException({
   79     73   
            #[allow(unused_mut)]
   80     74   
            let mut tmp = {
   81     75   
                #[allow(unused_mut)]
   82     76   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   83     77   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   84     78   
                    .map_err(crate::operation::delete_database::DeleteDatabaseError::unhandled)?;
   85     79   
                let output = output.meta(generic);

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_delete_table.rs

@@ -28,28 +105,99 @@
   48     48   
        "InvalidEndpointException" => crate::operation::delete_table::DeleteTableError::InvalidEndpointException({
   49     49   
            #[allow(unused_mut)]
   50     50   
            let mut tmp = {
   51     51   
                #[allow(unused_mut)]
   52     52   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   53     53   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   54     54   
                    .map_err(crate::operation::delete_table::DeleteTableError::unhandled)?;
   55     55   
                let output = output.meta(generic);
   56     56   
                output.build()
   57     57   
            };
   58         -
            if tmp.message.is_none() {
   59         -
                tmp.message = _error_message;
   60         -
            }
   61     58   
            tmp
   62     59   
        }),
   63     60   
        "ResourceNotFoundException" => crate::operation::delete_table::DeleteTableError::ResourceNotFoundException({
   64     61   
            #[allow(unused_mut)]
   65     62   
            let mut tmp = {
   66     63   
                #[allow(unused_mut)]
   67     64   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   68     65   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   69     66   
                    .map_err(crate::operation::delete_table::DeleteTableError::unhandled)?;
   70     67   
                let output = output.meta(generic);
   71     68   
                output.build()
   72     69   
            };
   73         -
            if tmp.message.is_none() {
   74         -
                tmp.message = _error_message;
   75         -
            }
   76     70   
            tmp
   77     71   
        }),
   78     72   
        "ThrottlingException" => crate::operation::delete_table::DeleteTableError::ThrottlingException({
   79     73   
            #[allow(unused_mut)]
   80     74   
            let mut tmp = {
   81     75   
                #[allow(unused_mut)]
   82     76   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   83     77   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   84     78   
                    .map_err(crate::operation::delete_table::DeleteTableError::unhandled)?;
   85     79   
                let output = output.meta(generic);

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_describe_batch_load_task.rs

@@ -31,31 +108,102 @@
   51     51   
        "InvalidEndpointException" => crate::operation::describe_batch_load_task::DescribeBatchLoadTaskError::InvalidEndpointException({
   52     52   
            #[allow(unused_mut)]
   53     53   
            let mut tmp = {
   54     54   
                #[allow(unused_mut)]
   55     55   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   56     56   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   57     57   
                    .map_err(crate::operation::describe_batch_load_task::DescribeBatchLoadTaskError::unhandled)?;
   58     58   
                let output = output.meta(generic);
   59     59   
                output.build()
   60     60   
            };
   61         -
            if tmp.message.is_none() {
   62         -
                tmp.message = _error_message;
   63         -
            }
   64     61   
            tmp
   65     62   
        }),
   66     63   
        "ResourceNotFoundException" => crate::operation::describe_batch_load_task::DescribeBatchLoadTaskError::ResourceNotFoundException({
   67     64   
            #[allow(unused_mut)]
   68     65   
            let mut tmp = {
   69     66   
                #[allow(unused_mut)]
   70     67   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   71     68   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   72     69   
                    .map_err(crate::operation::describe_batch_load_task::DescribeBatchLoadTaskError::unhandled)?;
   73     70   
                let output = output.meta(generic);
   74     71   
                output.build()
   75     72   
            };
   76         -
            if tmp.message.is_none() {
   77         -
                tmp.message = _error_message;
   78         -
            }
   79     73   
            tmp
   80     74   
        }),
   81     75   
        "ThrottlingException" => crate::operation::describe_batch_load_task::DescribeBatchLoadTaskError::ThrottlingException({
   82     76   
            #[allow(unused_mut)]
   83     77   
            let mut tmp = {
   84     78   
                #[allow(unused_mut)]
   85     79   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   86     80   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   87     81   
                    .map_err(crate::operation::describe_batch_load_task::DescribeBatchLoadTaskError::unhandled)?;
   88     82   
                let output = output.meta(generic);

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_describe_database.rs

@@ -28,28 +105,99 @@
   48     48   
        "InvalidEndpointException" => crate::operation::describe_database::DescribeDatabaseError::InvalidEndpointException({
   49     49   
            #[allow(unused_mut)]
   50     50   
            let mut tmp = {
   51     51   
                #[allow(unused_mut)]
   52     52   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   53     53   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   54     54   
                    .map_err(crate::operation::describe_database::DescribeDatabaseError::unhandled)?;
   55     55   
                let output = output.meta(generic);
   56     56   
                output.build()
   57     57   
            };
   58         -
            if tmp.message.is_none() {
   59         -
                tmp.message = _error_message;
   60         -
            }
   61     58   
            tmp
   62     59   
        }),
   63     60   
        "ResourceNotFoundException" => crate::operation::describe_database::DescribeDatabaseError::ResourceNotFoundException({
   64     61   
            #[allow(unused_mut)]
   65     62   
            let mut tmp = {
   66     63   
                #[allow(unused_mut)]
   67     64   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   68     65   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   69     66   
                    .map_err(crate::operation::describe_database::DescribeDatabaseError::unhandled)?;
   70     67   
                let output = output.meta(generic);
   71     68   
                output.build()
   72     69   
            };
   73         -
            if tmp.message.is_none() {
   74         -
                tmp.message = _error_message;
   75         -
            }
   76     70   
            tmp
   77     71   
        }),
   78     72   
        "ThrottlingException" => crate::operation::describe_database::DescribeDatabaseError::ThrottlingException({
   79     73   
            #[allow(unused_mut)]
   80     74   
            let mut tmp = {
   81     75   
                #[allow(unused_mut)]
   82     76   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   83     77   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   84     78   
                    .map_err(crate::operation::describe_database::DescribeDatabaseError::unhandled)?;
   85     79   
                let output = output.meta(generic);

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_describe_table.rs

@@ -28,28 +105,99 @@
   48     48   
        "InvalidEndpointException" => crate::operation::describe_table::DescribeTableError::InvalidEndpointException({
   49     49   
            #[allow(unused_mut)]
   50     50   
            let mut tmp = {
   51     51   
                #[allow(unused_mut)]
   52     52   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   53     53   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   54     54   
                    .map_err(crate::operation::describe_table::DescribeTableError::unhandled)?;
   55     55   
                let output = output.meta(generic);
   56     56   
                output.build()
   57     57   
            };
   58         -
            if tmp.message.is_none() {
   59         -
                tmp.message = _error_message;
   60         -
            }
   61     58   
            tmp
   62     59   
        }),
   63     60   
        "ResourceNotFoundException" => crate::operation::describe_table::DescribeTableError::ResourceNotFoundException({
   64     61   
            #[allow(unused_mut)]
   65     62   
            let mut tmp = {
   66     63   
                #[allow(unused_mut)]
   67     64   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   68     65   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   69     66   
                    .map_err(crate::operation::describe_table::DescribeTableError::unhandled)?;
   70     67   
                let output = output.meta(generic);
   71     68   
                output.build()
   72     69   
            };
   73         -
            if tmp.message.is_none() {
   74         -
                tmp.message = _error_message;
   75         -
            }
   76     70   
            tmp
   77     71   
        }),
   78     72   
        "ThrottlingException" => crate::operation::describe_table::DescribeTableError::ThrottlingException({
   79     73   
            #[allow(unused_mut)]
   80     74   
            let mut tmp = {
   81     75   
                #[allow(unused_mut)]
   82     76   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   83     77   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   84     78   
                    .map_err(crate::operation::describe_table::DescribeTableError::unhandled)?;
   85     79   
                let output = output.meta(generic);

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_list_batch_load_tasks.rs

@@ -31,31 +93,90 @@
   51     51   
        "InvalidEndpointException" => crate::operation::list_batch_load_tasks::ListBatchLoadTasksError::InvalidEndpointException({
   52     52   
            #[allow(unused_mut)]
   53     53   
            let mut tmp = {
   54     54   
                #[allow(unused_mut)]
   55     55   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   56     56   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   57     57   
                    .map_err(crate::operation::list_batch_load_tasks::ListBatchLoadTasksError::unhandled)?;
   58     58   
                let output = output.meta(generic);
   59     59   
                output.build()
   60     60   
            };
   61         -
            if tmp.message.is_none() {
   62         -
                tmp.message = _error_message;
   63         -
            }
   64     61   
            tmp
   65     62   
        }),
   66     63   
        "ThrottlingException" => crate::operation::list_batch_load_tasks::ListBatchLoadTasksError::ThrottlingException({
   67     64   
            #[allow(unused_mut)]
   68     65   
            let mut tmp = {
   69     66   
                #[allow(unused_mut)]
   70     67   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   71     68   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   72     69   
                    .map_err(crate::operation::list_batch_load_tasks::ListBatchLoadTasksError::unhandled)?;
   73     70   
                let output = output.meta(generic);

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_list_databases.rs

@@ -28,28 +90,87 @@
   48     48   
        "InvalidEndpointException" => crate::operation::list_databases::ListDatabasesError::InvalidEndpointException({
   49     49   
            #[allow(unused_mut)]
   50     50   
            let mut tmp = {
   51     51   
                #[allow(unused_mut)]
   52     52   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   53     53   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   54     54   
                    .map_err(crate::operation::list_databases::ListDatabasesError::unhandled)?;
   55     55   
                let output = output.meta(generic);
   56     56   
                output.build()
   57     57   
            };
   58         -
            if tmp.message.is_none() {
   59         -
                tmp.message = _error_message;
   60         -
            }
   61     58   
            tmp
   62     59   
        }),
   63     60   
        "ThrottlingException" => crate::operation::list_databases::ListDatabasesError::ThrottlingException({
   64     61   
            #[allow(unused_mut)]
   65     62   
            let mut tmp = {
   66     63   
                #[allow(unused_mut)]
   67     64   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   68     65   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   69     66   
                    .map_err(crate::operation::list_databases::ListDatabasesError::unhandled)?;
   70     67   
                let output = output.meta(generic);

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_list_tables.rs

@@ -28,28 +105,99 @@
   48     48   
        "InvalidEndpointException" => crate::operation::list_tables::ListTablesError::InvalidEndpointException({
   49     49   
            #[allow(unused_mut)]
   50     50   
            let mut tmp = {
   51     51   
                #[allow(unused_mut)]
   52     52   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   53     53   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   54     54   
                    .map_err(crate::operation::list_tables::ListTablesError::unhandled)?;
   55     55   
                let output = output.meta(generic);
   56     56   
                output.build()
   57     57   
            };
   58         -
            if tmp.message.is_none() {
   59         -
                tmp.message = _error_message;
   60         -
            }
   61     58   
            tmp
   62     59   
        }),
   63     60   
        "ResourceNotFoundException" => crate::operation::list_tables::ListTablesError::ResourceNotFoundException({
   64     61   
            #[allow(unused_mut)]
   65     62   
            let mut tmp = {
   66     63   
                #[allow(unused_mut)]
   67     64   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   68     65   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   69     66   
                    .map_err(crate::operation::list_tables::ListTablesError::unhandled)?;
   70     67   
                let output = output.meta(generic);
   71     68   
                output.build()
   72     69   
            };
   73         -
            if tmp.message.is_none() {
   74         -
                tmp.message = _error_message;
   75         -
            }
   76     70   
            tmp
   77     71   
        }),
   78     72   
        "ThrottlingException" => crate::operation::list_tables::ListTablesError::ThrottlingException({
   79     73   
            #[allow(unused_mut)]
   80     74   
            let mut tmp = {
   81     75   
                #[allow(unused_mut)]
   82     76   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   83     77   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   84     78   
                    .map_err(crate::operation::list_tables::ListTablesError::unhandled)?;
   85     79   
                let output = output.meta(generic);

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

@@ -3,3 +80,74 @@
   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);

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_resume_batch_load_task.rs

@@ -31,31 +108,102 @@
   51     51   
        "InvalidEndpointException" => crate::operation::resume_batch_load_task::ResumeBatchLoadTaskError::InvalidEndpointException({
   52     52   
            #[allow(unused_mut)]
   53     53   
            let mut tmp = {
   54     54   
                #[allow(unused_mut)]
   55     55   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   56     56   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   57     57   
                    .map_err(crate::operation::resume_batch_load_task::ResumeBatchLoadTaskError::unhandled)?;
   58     58   
                let output = output.meta(generic);
   59     59   
                output.build()
   60     60   
            };
   61         -
            if tmp.message.is_none() {
   62         -
                tmp.message = _error_message;
   63         -
            }
   64     61   
            tmp
   65     62   
        }),
   66     63   
        "ResourceNotFoundException" => crate::operation::resume_batch_load_task::ResumeBatchLoadTaskError::ResourceNotFoundException({
   67     64   
            #[allow(unused_mut)]
   68     65   
            let mut tmp = {
   69     66   
                #[allow(unused_mut)]
   70     67   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   71     68   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   72     69   
                    .map_err(crate::operation::resume_batch_load_task::ResumeBatchLoadTaskError::unhandled)?;
   73     70   
                let output = output.meta(generic);
   74     71   
                output.build()
   75     72   
            };
   76         -
            if tmp.message.is_none() {
   77         -
                tmp.message = _error_message;
   78         -
            }
   79     73   
            tmp
   80     74   
        }),
   81     75   
        "ThrottlingException" => crate::operation::resume_batch_load_task::ResumeBatchLoadTaskError::ThrottlingException({
   82     76   
            #[allow(unused_mut)]
   83     77   
            let mut tmp = {
   84     78   
                #[allow(unused_mut)]
   85     79   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   86     80   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   87     81   
                    .map_err(crate::operation::resume_batch_load_task::ResumeBatchLoadTaskError::unhandled)?;
   88     82   
                let output = output.meta(generic);

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

@@ -1,1 +95,86 @@
   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);

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

@@ -1,1 +95,86 @@
   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   
        "ServiceQuotaExceededException" => crate::operation::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::unhandled)?;
   75     66   
                let output = output.meta(generic);