AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df

Files changed:

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/protocol_serde/shape_put_subscription_filter.rs

@@ -3,3 +141,123 @@
   23     23   
        "InvalidOperationException" => crate::operation::put_subscription_filter::PutSubscriptionFilterError::InvalidOperationException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidOperationExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_operation_exception::de_invalid_operation_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::put_subscription_filter::PutSubscriptionFilterError::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::put_subscription_filter::PutSubscriptionFilterError::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::put_subscription_filter::PutSubscriptionFilterError::unhandled)?;
   45     42   
                let output = output.meta(generic);
   46     43   
                output.build()
   47     44   
            };
   48         -
            if tmp.message.is_none() {
   49         -
                tmp.message = _error_message;
   50         -
            }
   51     45   
            tmp
   52     46   
        }),
   53     47   
        "InvalidParameterException" => crate::operation::put_subscription_filter::PutSubscriptionFilterError::InvalidParameterException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::put_subscription_filter::PutSubscriptionFilterError::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   
        "LimitExceededException" => crate::operation::put_subscription_filter::PutSubscriptionFilterError::LimitExceededException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::put_subscription_filter::PutSubscriptionFilterError::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   
        "OperationAbortedException" => crate::operation::put_subscription_filter::PutSubscriptionFilterError::OperationAbortedException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::OperationAbortedExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_operation_aborted_exception::de_operation_aborted_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::put_subscription_filter::PutSubscriptionFilterError::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   
        "ServiceUnavailableException" => crate::operation::put_subscription_filter::PutSubscriptionFilterError::ServiceUnavailableException({
   99     84   
            #[allow(unused_mut)]
  100     85   
            let mut tmp = {
  101     86   
                #[allow(unused_mut)]
  102     87   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
  103     88   
                output =
  104     89   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
  105     90   
                        .map_err(crate::operation::put_subscription_filter::PutSubscriptionFilterError::unhandled)?;
  106     91   
                let output = output.meta(generic);
  107     92   
                output.build()
  108     93   
            };
  109         -
            if tmp.message.is_none() {
  110         -
                tmp.message = _error_message;
  111         -
            }
  112     94   
            tmp
  113     95   
        }),
  114     96   
        _ => crate::operation::put_subscription_filter::PutSubscriptionFilterError::generic(generic),
  115     97   
    })
  116     98   
}
  117     99   
  118    100   
#[allow(clippy::unnecessary_wraps)]
  119    101   
pub fn de_put_subscription_filter_http_response(
  120    102   
    _response_status: u16,
  121    103   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/protocol_serde/shape_put_transformer.rs

@@ -1,1 +137,119 @@
   20     20   
        "InvalidOperationException" => crate::operation::put_transformer::PutTransformerError::InvalidOperationException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidOperationExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_operation_exception::de_invalid_operation_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::put_transformer::PutTransformerError::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::put_transformer::PutTransformerError::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::put_transformer::PutTransformerError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "InvalidParameterException" => crate::operation::put_transformer::PutTransformerError::InvalidParameterException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::put_transformer::PutTransformerError::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   
        "LimitExceededException" => crate::operation::put_transformer::PutTransformerError::LimitExceededException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::put_transformer::PutTransformerError::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   
        "OperationAbortedException" => crate::operation::put_transformer::PutTransformerError::OperationAbortedException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::OperationAbortedExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_operation_aborted_exception::de_operation_aborted_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::put_transformer::PutTransformerError::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   
        "ServiceUnavailableException" => crate::operation::put_transformer::PutTransformerError::ServiceUnavailableException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
  100     85   
                output =
  101     86   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
  102     87   
                        .map_err(crate::operation::put_transformer::PutTransformerError::unhandled)?;
  103     88   
                let output = output.meta(generic);
  104     89   
                output.build()
  105     90   
            };
  106         -
            if tmp.message.is_none() {
  107         -
                tmp.message = _error_message;
  108         -
            }
  109     91   
            tmp
  110     92   
        }),
  111     93   
        _ => crate::operation::put_transformer::PutTransformerError::generic(generic),
  112     94   
    })
  113     95   
}
  114     96   
  115     97   
#[allow(clippy::unnecessary_wraps)]
  116     98   
pub fn de_put_transformer_http_response(
  117     99   
    _response_status: u16,
  118    100   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/protocol_serde/shape_start_live_tail.rs

@@ -21,21 +158,137 @@
   41     41   
        "InvalidOperationException" => crate::operation::start_live_tail::StartLiveTailError::InvalidOperationException({
   42     42   
            #[allow(unused_mut)]
   43     43   
            let mut tmp = {
   44     44   
                #[allow(unused_mut)]
   45     45   
                let mut output = crate::types::error::builders::InvalidOperationExceptionBuilder::default();
   46     46   
                output = crate::protocol_serde::shape_invalid_operation_exception::de_invalid_operation_exception_json_err(_response_body, output)
   47     47   
                    .map_err(crate::operation::start_live_tail::StartLiveTailError::unhandled)?;
   48     48   
                let output = output.meta(generic);
   49     49   
                output.build()
   50     50   
            };
   51         -
            if tmp.message.is_none() {
   52         -
                tmp.message = _error_message;
   53         -
            }
   54     51   
            tmp
   55     52   
        }),
   56     53   
        "ResourceNotFoundException" => crate::operation::start_live_tail::StartLiveTailError::ResourceNotFoundException({
   57     54   
            #[allow(unused_mut)]
   58     55   
            let mut tmp = {
   59     56   
                #[allow(unused_mut)]
   60     57   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   61     58   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   62     59   
                    .map_err(crate::operation::start_live_tail::StartLiveTailError::unhandled)?;
   63     60   
                let output = output.meta(generic);
   64     61   
                output.build()
   65     62   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     63   
            tmp
   70     64   
        }),
   71     65   
        "AccessDeniedException" => crate::operation::start_live_tail::StartLiveTailError::AccessDeniedException({
   72     66   
            #[allow(unused_mut)]
   73     67   
            let mut tmp = {
   74     68   
                #[allow(unused_mut)]
   75     69   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   76     70   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   77     71   
                    .map_err(crate::operation::start_live_tail::StartLiveTailError::unhandled)?;
   78     72   
                let output = output.meta(generic);
   79     73   
                output.build()
   80     74   
            };
   81         -
            if tmp.message.is_none() {
   82         -
                tmp.message = _error_message;
   83         -
            }
   84     75   
            tmp
   85     76   
        }),
   86     77   
        "InvalidParameterException" => crate::operation::start_live_tail::StartLiveTailError::InvalidParameterException({
   87     78   
            #[allow(unused_mut)]
   88     79   
            let mut tmp = {
   89     80   
                #[allow(unused_mut)]
   90     81   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   91     82   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   92     83   
                    .map_err(crate::operation::start_live_tail::StartLiveTailError::unhandled)?;
   93     84   
                let output = output.meta(generic);
   94     85   
                output.build()
   95     86   
            };
   96         -
            if tmp.message.is_none() {
   97         -
                tmp.message = _error_message;
   98         -
            }
   99     87   
            tmp
  100     88   
        }),
  101     89   
        "LimitExceededException" => crate::operation::start_live_tail::StartLiveTailError::LimitExceededException({
  102     90   
            #[allow(unused_mut)]
  103     91   
            let mut tmp = {
  104     92   
                #[allow(unused_mut)]
  105     93   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
  106     94   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
  107     95   
                    .map_err(crate::operation::start_live_tail::StartLiveTailError::unhandled)?;
  108     96   
                let output = output.meta(generic);
  109     97   
                output.build()
  110     98   
            };
  111         -
            if tmp.message.is_none() {
  112         -
                tmp.message = _error_message;
  113         -
            }
  114     99   
            tmp
  115    100   
        }),
  116    101   
        "SessionTimeoutException" => crate::operation::start_live_tail::StartLiveTailError::SessionTimeoutException({
  117    102   
            #[allow(unused_mut)]
  118    103   
            let mut tmp = {
  119    104   
                #[allow(unused_mut)]
  120    105   
                let mut output = crate::types::error::builders::SessionTimeoutExceptionBuilder::default();
  121    106   
                output = crate::protocol_serde::shape_session_timeout_exception::de_session_timeout_exception_json_err(_response_body, output)
  122    107   
                    .map_err(crate::operation::start_live_tail::StartLiveTailError::unhandled)?;
  123    108   
                let output = output.meta(generic);
  124    109   
                output.build()
  125    110   
            };
  126         -
            if tmp.message.is_none() {
  127         -
                tmp.message = _error_message;
  128         -
            }
  129    111   
            tmp
  130    112   
        }),
  131    113   
        "SessionStreamingException" => crate::operation::start_live_tail::StartLiveTailError::SessionStreamingException({
  132    114   
            #[allow(unused_mut)]
  133    115   
            let mut tmp = {
  134    116   
                #[allow(unused_mut)]
  135    117   
                let mut output = crate::types::error::builders::SessionStreamingExceptionBuilder::default();
  136    118   
                output = crate::protocol_serde::shape_session_streaming_exception::de_session_streaming_exception_json_err(_response_body, output)
  137    119   
                    .map_err(crate::operation::start_live_tail::StartLiveTailError::unhandled)?;
  138    120   
                let output = output.meta(generic);
  139    121   
                output.build()
  140    122   
            };
  141         -
            if tmp.message.is_none() {
  142         -
                tmp.message = _error_message;
  143         -
            }
  144    123   
            tmp
  145    124   
        }),
  146    125   
        _ => crate::operation::start_live_tail::StartLiveTailError::generic(generic),
  147    126   
    })
  148    127   
}
  149    128   
  150    129   
pub fn ser_start_live_tail_input(
  151    130   
    input: &crate::operation::start_live_tail::StartLiveTailInput,
  152    131   
) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
  153    132   
    let mut out = String::new();

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/protocol_serde/shape_start_query.rs

@@ -1,1 +123,108 @@
   20     20   
        "MalformedQueryException" => crate::operation::start_query::StartQueryError::MalformedQueryException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::MalformedQueryExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_malformed_query_exception::de_malformed_query_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::start_query::StartQueryError::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::start_query::StartQueryError::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::start_query::StartQueryError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "InvalidParameterException" => crate::operation::start_query::StartQueryError::InvalidParameterException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::start_query::StartQueryError::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   
        "LimitExceededException" => crate::operation::start_query::StartQueryError::LimitExceededException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::start_query::StartQueryError::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   
        "ServiceUnavailableException" => crate::operation::start_query::StartQueryError::ServiceUnavailableException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   85     73   
                output =
   86     74   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   87     75   
                        .map_err(crate::operation::start_query::StartQueryError::unhandled)?;
   88     76   
                let output = output.meta(generic);
   89     77   
                output.build()
   90     78   
            };
   91         -
            if tmp.message.is_none() {
   92         -
                tmp.message = _error_message;
   93         -
            }
   94     79   
            tmp
   95     80   
        }),
   96     81   
        _ => crate::operation::start_query::StartQueryError::generic(generic),
   97     82   
    })
   98     83   
}
   99     84   
  100     85   
#[allow(clippy::unnecessary_wraps)]
  101     86   
pub fn de_start_query_http_response(
  102     87   
    _response_status: u16,
  103     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/protocol_serde/shape_stop_query.rs

@@ -1,1 +93,84 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::stop_query::StopQueryError::ResourceNotFoundException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::stop_query::StopQueryError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "InvalidParameterException" => crate::operation::stop_query::StopQueryError::InvalidParameterException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::stop_query::StopQueryError::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   
        "ServiceUnavailableException" => crate::operation::stop_query::StopQueryError::ServiceUnavailableException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   55     49   
                output =
   56     50   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   57     51   
                        .map_err(crate::operation::stop_query::StopQueryError::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::stop_query::StopQueryError::generic(generic),
   67     58   
    })
   68     59   
}
   69     60   
   70     61   
#[allow(clippy::unnecessary_wraps)]
   71     62   
pub fn de_stop_query_http_response(
   72     63   
    _response_status: u16,
   73     64   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/protocol_serde/shape_tag_log_group.rs

@@ -1,1 +76,70 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::tag_log_group::TagLogGroupError::ResourceNotFoundException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::tag_log_group::TagLogGroupError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "InvalidParameterException" => crate::operation::tag_log_group::TagLogGroupError::InvalidParameterException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::tag_log_group::TagLogGroupError::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   
        _ => crate::operation::tag_log_group::TagLogGroupError::generic(generic),
   51     45   
    })
   52     46   
}
   53     47   
   54     48   
#[allow(clippy::unnecessary_wraps)]
   55     49   
pub fn de_tag_log_group_http_response(
   56     50   
    _response_status: u16,
   57     51   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +107,95 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::tag_resource::TagResourceError::ResourceNotFoundException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_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   
        "InvalidParameterException" => crate::operation::tag_resource::TagResourceError::InvalidParameterException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::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   
        "ServiceUnavailableException" => crate::operation::tag_resource::TagResourceError::ServiceUnavailableException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   55     49   
                output =
   56     50   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   57     51   
                        .map_err(crate::operation::tag_resource::TagResourceError::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   
        "TooManyTagsException" => crate::operation::tag_resource::TagResourceError::TooManyTagsException({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::TooManyTagsExceptionBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_too_many_tags_exception::de_too_many_tags_exception_json_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::tag_resource::TagResourceError::unhandled)?;
   73     64   
                let output = output.meta(generic);
   74     65   
                output.build()
   75     66   
            };
   76         -
            if tmp.message.is_none() {
   77         -
                tmp.message = _error_message;
   78         -
            }
   79     67   
            tmp
   80     68   
        }),
   81     69   
        _ => crate::operation::tag_resource::TagResourceError::generic(generic),
   82     70   
    })
   83     71   
}
   84     72   
   85     73   
#[allow(clippy::unnecessary_wraps)]
   86     74   
pub fn de_tag_resource_http_response(
   87     75   
    _response_status: u16,
   88     76   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/protocol_serde/shape_test_metric_filter.rs

@@ -1,1 +78,72 @@
   20     20   
        "InvalidParameterException" => crate::operation::test_metric_filter::TestMetricFilterError::InvalidParameterException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::test_metric_filter::TestMetricFilterError::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   
        "ServiceUnavailableException" => crate::operation::test_metric_filter::TestMetricFilterError::ServiceUnavailableException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   40     37   
                output =
   41     38   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   42     39   
                        .map_err(crate::operation::test_metric_filter::TestMetricFilterError::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   
        _ => crate::operation::test_metric_filter::TestMetricFilterError::generic(generic),
   52     46   
    })
   53     47   
}
   54     48   
   55     49   
#[allow(clippy::unnecessary_wraps)]
   56     50   
pub fn de_test_metric_filter_http_response(
   57     51   
    _response_status: u16,
   58     52   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/protocol_serde/shape_test_transformer.rs

@@ -1,1 +93,84 @@
   20     20   
        "InvalidOperationException" => crate::operation::test_transformer::TestTransformerError::InvalidOperationException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidOperationExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_operation_exception::de_invalid_operation_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::test_transformer::TestTransformerError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "InvalidParameterException" => crate::operation::test_transformer::TestTransformerError::InvalidParameterException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::test_transformer::TestTransformerError::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   
        "ServiceUnavailableException" => crate::operation::test_transformer::TestTransformerError::ServiceUnavailableException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   55     49   
                output =
   56     50   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   57     51   
                        .map_err(crate::operation::test_transformer::TestTransformerError::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::test_transformer::TestTransformerError::generic(generic),
   67     58   
    })
   68     59   
}
   69     60   
   70     61   
#[allow(clippy::unnecessary_wraps)]
   71     62   
pub fn de_test_transformer_http_response(
   72     63   
    _response_status: u16,
   73     64   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/protocol_serde/shape_untag_log_group.rs

@@ -1,1 +61,58 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::untag_log_group::UntagLogGroupError::ResourceNotFoundException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::untag_log_group::UntagLogGroupError::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::untag_log_group::UntagLogGroupError::generic(generic),
   36     33   
    })
   37     34   
}
   38     35   
   39     36   
#[allow(clippy::unnecessary_wraps)]
   40     37   
pub fn de_untag_log_group_http_response(
   41     38   
    _response_status: u16,
   42     39   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +92,83 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::untag_resource::UntagResourceError::ResourceNotFoundException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_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   
        "InvalidParameterException" => crate::operation::untag_resource::UntagResourceError::InvalidParameterException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::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   
        "ServiceUnavailableException" => crate::operation::untag_resource::UntagResourceError::ServiceUnavailableException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   55     49   
                output =
   56     50   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   57     51   
                        .map_err(crate::operation::untag_resource::UntagResourceError::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::untag_resource::UntagResourceError::generic(generic),
   67     58   
    })
   68     59   
}
   69     60   
   70     61   
#[allow(clippy::unnecessary_wraps)]
   71     62   
pub fn de_untag_resource_http_response(
   72     63   
    _response_status: u16,
   73     64   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/protocol_serde/shape_update_anomaly.rs

@@ -1,1 +107,95 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::update_anomaly::UpdateAnomalyError::ResourceNotFoundException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::update_anomaly::UpdateAnomalyError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "InvalidParameterException" => crate::operation::update_anomaly::UpdateAnomalyError::InvalidParameterException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::update_anomaly::UpdateAnomalyError::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   
        "OperationAbortedException" => crate::operation::update_anomaly::UpdateAnomalyError::OperationAbortedException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::OperationAbortedExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_operation_aborted_exception::de_operation_aborted_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::update_anomaly::UpdateAnomalyError::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   
        "ServiceUnavailableException" => crate::operation::update_anomaly::UpdateAnomalyError::ServiceUnavailableException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   70     61   
                output =
   71     62   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   72     63   
                        .map_err(crate::operation::update_anomaly::UpdateAnomalyError::unhandled)?;
   73     64   
                let output = output.meta(generic);
   74     65   
                output.build()
   75     66   
            };
   76         -
            if tmp.message.is_none() {
   77         -
                tmp.message = _error_message;
   78         -
            }
   79     67   
            tmp
   80     68   
        }),
   81     69   
        _ => crate::operation::update_anomaly::UpdateAnomalyError::generic(generic),
   82     70   
    })
   83     71   
}
   84     72   
   85     73   
#[allow(clippy::unnecessary_wraps)]
   86     74   
pub fn de_update_anomaly_http_response(
   87     75   
    _response_status: u16,
   88     76   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/protocol_serde/shape_update_delivery_configuration.rs

@@ -3,3 +145,127 @@
   23     23   
        "ThrottlingException" => crate::operation::update_delivery_configuration::UpdateDeliveryConfigurationError::ThrottlingException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::update_delivery_configuration::UpdateDeliveryConfigurationError::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::update_delivery_configuration::UpdateDeliveryConfigurationError::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::update_delivery_configuration::UpdateDeliveryConfigurationError::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   
        "ValidationException" => crate::operation::update_delivery_configuration::UpdateDeliveryConfigurationError::ValidationException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::update_delivery_configuration::UpdateDeliveryConfigurationError::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" => {
   69     60   
            crate::operation::update_delivery_configuration::UpdateDeliveryConfigurationError::ResourceNotFoundException({
   70     61   
                #[allow(unused_mut)]
   71     62   
                let mut tmp = {
   72     63   
                    #[allow(unused_mut)]
   73     64   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   74     65   
                    output =
   75     66   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   76     67   
                            .map_err(crate::operation::update_delivery_configuration::UpdateDeliveryConfigurationError::unhandled)?;
   77     68   
                    let output = output.meta(generic);
   78     69   
                    output.build()
   79     70   
                };
   80         -
                if tmp.message.is_none() {
   81         -
                    tmp.message = _error_message;
   82         -
                }
   83     71   
                tmp
   84     72   
            })
   85     73   
        }
   86     74   
        "AccessDeniedException" => crate::operation::update_delivery_configuration::UpdateDeliveryConfigurationError::AccessDeniedException({
   87     75   
            #[allow(unused_mut)]
   88     76   
            let mut tmp = {
   89     77   
                #[allow(unused_mut)]
   90     78   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   91     79   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   92     80   
                    .map_err(crate::operation::update_delivery_configuration::UpdateDeliveryConfigurationError::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   
        "ServiceUnavailableException" => {
  102     87   
            crate::operation::update_delivery_configuration::UpdateDeliveryConfigurationError::ServiceUnavailableException({
  103     88   
                #[allow(unused_mut)]
  104     89   
                let mut tmp = {
  105     90   
                    #[allow(unused_mut)]
  106     91   
                    let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
  107     92   
                    output =
  108     93   
                        crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
  109     94   
                            .map_err(crate::operation::update_delivery_configuration::UpdateDeliveryConfigurationError::unhandled)?;
  110     95   
                    let output = output.meta(generic);
  111     96   
                    output.build()
  112     97   
                };
  113         -
                if tmp.message.is_none() {
  114         -
                    tmp.message = _error_message;
  115         -
                }
  116     98   
                tmp
  117     99   
            })
  118    100   
        }
  119    101   
        _ => crate::operation::update_delivery_configuration::UpdateDeliveryConfigurationError::generic(generic),
  120    102   
    })
  121    103   
}
  122    104   
  123    105   
#[allow(clippy::unnecessary_wraps)]
  124    106   
pub fn de_update_delivery_configuration_http_response(
  125    107   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/protocol_serde/shape_update_log_anomaly_detector.rs

@@ -7,7 +115,103 @@
   27     27   
        "ResourceNotFoundException" => crate::operation::update_log_anomaly_detector::UpdateLogAnomalyDetectorError::ResourceNotFoundException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::update_log_anomaly_detector::UpdateLogAnomalyDetectorError::unhandled)?;
   34     34   
                let output = output.meta(generic);
   35     35   
                output.build()
   36     36   
            };
   37         -
            if tmp.message.is_none() {
   38         -
                tmp.message = _error_message;
   39         -
            }
   40     37   
            tmp
   41     38   
        }),
   42     39   
        "InvalidParameterException" => crate::operation::update_log_anomaly_detector::UpdateLogAnomalyDetectorError::InvalidParameterException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::update_log_anomaly_detector::UpdateLogAnomalyDetectorError::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   
        "OperationAbortedException" => crate::operation::update_log_anomaly_detector::UpdateLogAnomalyDetectorError::OperationAbortedException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::OperationAbortedExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_operation_aborted_exception::de_operation_aborted_exception_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::update_log_anomaly_detector::UpdateLogAnomalyDetectorError::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   
        "ServiceUnavailableException" => crate::operation::update_log_anomaly_detector::UpdateLogAnomalyDetectorError::ServiceUnavailableException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   77     68   
                output =
   78     69   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   79     70   
                        .map_err(crate::operation::update_log_anomaly_detector::UpdateLogAnomalyDetectorError::unhandled)?;
   80     71   
                let output = output.meta(generic);
   81     72   
                output.build()
   82     73   
            };
   83         -
            if tmp.message.is_none() {
   84         -
                tmp.message = _error_message;
   85         -
            }
   86     74   
            tmp
   87     75   
        }),
   88     76   
        _ => crate::operation::update_log_anomaly_detector::UpdateLogAnomalyDetectorError::generic(generic),
   89     77   
    })
   90     78   
}
   91     79   
   92     80   
#[allow(clippy::unnecessary_wraps)]
   93     81   
pub fn de_update_log_anomaly_detector_http_response(
   94     82   
    _response_status: u16,
   95     83   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_query_compile_error.rs

@@ -1,1 +51,67 @@
   12     12   
impl QueryCompileError {
   13     13   
    /// <p>Reserved.</p>
   14     14   
    pub fn location(&self) -> ::std::option::Option<&crate::types::QueryCompileErrorLocation> {
   15     15   
        self.location.as_ref()
   16     16   
    }
   17     17   
    /// <p>Reserved.</p>
   18     18   
    pub fn message(&self) -> ::std::option::Option<&str> {
   19     19   
        self.message.as_deref()
   20     20   
    }
   21     21   
}
          22  +
impl ::std::fmt::Display for QueryCompileError {
          23  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          24  +
        ::std::write!(f, "QueryCompileError {{")?;
          25  +
        if let ::std::option::Option::Some(inner) = &self.location {
          26  +
            ::std::write!(f, "location=Some({})", inner)?;
          27  +
        } else {
          28  +
            ::std::write!(f, "location=None")?;
          29  +
        }
          30  +
        if let ::std::option::Option::Some(inner) = &self.message {
          31  +
            ::std::write!(f, ", message=Some({})", inner)?;
          32  +
        } else {
          33  +
            ::std::write!(f, ", message=None")?;
          34  +
        }
          35  +
        ::std::write!(f, "}}")
          36  +
    }
          37  +
}
   22     38   
impl QueryCompileError {
   23     39   
    /// Creates a new builder-style object to manufacture [`QueryCompileError`](crate::types::QueryCompileError).
   24     40   
    pub fn builder() -> crate::types::builders::QueryCompileErrorBuilder {
   25     41   
        crate::types::builders::QueryCompileErrorBuilder::default()
   26     42   
    }
   27     43   
}
   28     44   
   29     45   
/// A builder for [`QueryCompileError`](crate::types::QueryCompileError).
   30     46   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   31     47   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_query_compile_error_location.rs

@@ -1,1 +51,67 @@
   12     12   
impl QueryCompileErrorLocation {
   13     13   
    /// <p>Reserved.</p>
   14     14   
    pub fn start_char_offset(&self) -> ::std::option::Option<i32> {
   15     15   
        self.start_char_offset
   16     16   
    }
   17     17   
    /// <p>Reserved.</p>
   18     18   
    pub fn end_char_offset(&self) -> ::std::option::Option<i32> {
   19     19   
        self.end_char_offset
   20     20   
    }
   21     21   
}
          22  +
impl ::std::fmt::Display for QueryCompileErrorLocation {
          23  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          24  +
        ::std::write!(f, "QueryCompileErrorLocation {{")?;
          25  +
        if let ::std::option::Option::Some(inner) = &self.start_char_offset {
          26  +
            ::std::write!(f, "start_char_offset=Some({})", inner)?;
          27  +
        } else {
          28  +
            ::std::write!(f, "start_char_offset=None")?;
          29  +
        }
          30  +
        if let ::std::option::Option::Some(inner) = &self.end_char_offset {
          31  +
            ::std::write!(f, ", end_char_offset=Some({})", inner)?;
          32  +
        } else {
          33  +
            ::std::write!(f, ", end_char_offset=None")?;
          34  +
        }
          35  +
        ::std::write!(f, "}}")
          36  +
    }
          37  +
}
   22     38   
impl QueryCompileErrorLocation {
   23     39   
    /// Creates a new builder-style object to manufacture [`QueryCompileErrorLocation`](crate::types::QueryCompileErrorLocation).
   24     40   
    pub fn builder() -> crate::types::builders::QueryCompileErrorLocationBuilder {
   25     41   
        crate::types::builders::QueryCompileErrorLocationBuilder::default()
   26     42   
    }
   27     43   
}
   28     44   
   29     45   
/// A builder for [`QueryCompileErrorLocation`](crate::types::QueryCompileErrorLocation).
   30     46   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   31     47   
#[non_exhaustive]