AWS SDK

AWS SDK

rev. 024d02a2e8f38a611999fe239a68eb14068662df (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/protocol_serde/shape_converse.rs

@@ -1,1 +167,143 @@
   20     20   
        "ModelTimeoutException" => crate::operation::converse::ConverseError::ModelTimeoutException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ModelTimeoutExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_model_timeout_exception::de_model_timeout_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::converse::ConverseError::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   
        "AccessDeniedException" => crate::operation::converse::ConverseError::AccessDeniedException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::converse::ConverseError::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   
        "ResourceNotFoundException" => crate::operation::converse::ConverseError::ResourceNotFoundException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::converse::ConverseError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "ThrottlingException" => crate::operation::converse::ConverseError::ThrottlingException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::converse::ConverseError::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   
        "InternalServerException" => crate::operation::converse::ConverseError::InternalServerException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::converse::ConverseError::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   
        "ValidationException" => crate::operation::converse::ConverseError::ValidationException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
  100     85   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  101     86   
                    .map_err(crate::operation::converse::ConverseError::unhandled)?;
  102     87   
                let output = output.meta(generic);
  103     88   
                output.build()
  104     89   
            };
  105         -
            if tmp.message.is_none() {
  106         -
                tmp.message = _error_message;
  107         -
            }
  108     90   
            tmp
  109     91   
        }),
  110     92   
        "ModelNotReadyException" => crate::operation::converse::ConverseError::ModelNotReadyException({
  111     93   
            #[allow(unused_mut)]
  112     94   
            let mut tmp = {
  113     95   
                #[allow(unused_mut)]
  114     96   
                let mut output = crate::types::error::builders::ModelNotReadyExceptionBuilder::default();
  115     97   
                output = crate::protocol_serde::shape_model_not_ready_exception::de_model_not_ready_exception_json_err(_response_body, output)
  116     98   
                    .map_err(crate::operation::converse::ConverseError::unhandled)?;
  117     99   
                let output = output.meta(generic);
  118    100   
                output.build()
  119    101   
            };
  120         -
            if tmp.message.is_none() {
  121         -
                tmp.message = _error_message;
  122         -
            }
  123    102   
            tmp
  124    103   
        }),
  125    104   
        "ModelErrorException" => crate::operation::converse::ConverseError::ModelErrorException({
  126    105   
            #[allow(unused_mut)]
  127    106   
            let mut tmp = {
  128    107   
                #[allow(unused_mut)]
  129    108   
                let mut output = crate::types::error::builders::ModelErrorExceptionBuilder::default();
  130    109   
                output = crate::protocol_serde::shape_model_error_exception::de_model_error_exception_json_err(_response_body, output)
  131    110   
                    .map_err(crate::operation::converse::ConverseError::unhandled)?;
  132    111   
                let output = output.meta(generic);
  133    112   
                output.build()
  134    113   
            };
  135         -
            if tmp.message.is_none() {
  136         -
                tmp.message = _error_message;
  137         -
            }
  138    114   
            tmp
  139    115   
        }),
  140    116   
        _ => crate::operation::converse::ConverseError::generic(generic),
  141    117   
    })
  142    118   
}
  143    119   
  144    120   
#[allow(clippy::unnecessary_wraps)]
  145    121   
pub fn de_converse_http_response(
  146    122   
    _response_status: u16,
  147    123   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/protocol_serde/shape_converse_stream.rs

@@ -23,23 +190,163 @@
   43     43   
        "ModelTimeoutException" => crate::operation::converse_stream::ConverseStreamError::ModelTimeoutException({
   44     44   
            #[allow(unused_mut)]
   45     45   
            let mut tmp = {
   46     46   
                #[allow(unused_mut)]
   47     47   
                let mut output = crate::types::error::builders::ModelTimeoutExceptionBuilder::default();
   48     48   
                output = crate::protocol_serde::shape_model_timeout_exception::de_model_timeout_exception_json_err(_response_body, output)
   49     49   
                    .map_err(crate::operation::converse_stream::ConverseStreamError::unhandled)?;
   50     50   
                let output = output.meta(generic);
   51     51   
                output.build()
   52     52   
            };
   53         -
            if tmp.message.is_none() {
   54         -
                tmp.message = _error_message;
   55         -
            }
   56     53   
            tmp
   57     54   
        }),
   58     55   
        "AccessDeniedException" => crate::operation::converse_stream::ConverseStreamError::AccessDeniedException({
   59     56   
            #[allow(unused_mut)]
   60     57   
            let mut tmp = {
   61     58   
                #[allow(unused_mut)]
   62     59   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   63     60   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   64     61   
                    .map_err(crate::operation::converse_stream::ConverseStreamError::unhandled)?;
   65     62   
                let output = output.meta(generic);
   66     63   
                output.build()
   67     64   
            };
   68         -
            if tmp.message.is_none() {
   69         -
                tmp.message = _error_message;
   70         -
            }
   71     65   
            tmp
   72     66   
        }),
   73     67   
        "ResourceNotFoundException" => crate::operation::converse_stream::ConverseStreamError::ResourceNotFoundException({
   74     68   
            #[allow(unused_mut)]
   75     69   
            let mut tmp = {
   76     70   
                #[allow(unused_mut)]
   77     71   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   78     72   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   79     73   
                    .map_err(crate::operation::converse_stream::ConverseStreamError::unhandled)?;
   80     74   
                let output = output.meta(generic);
   81     75   
                output.build()
   82     76   
            };
   83         -
            if tmp.message.is_none() {
   84         -
                tmp.message = _error_message;
   85         -
            }
   86     77   
            tmp
   87     78   
        }),
   88     79   
        "ThrottlingException" => crate::operation::converse_stream::ConverseStreamError::ThrottlingException({
   89     80   
            #[allow(unused_mut)]
   90     81   
            let mut tmp = {
   91     82   
                #[allow(unused_mut)]
   92     83   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   93     84   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   94     85   
                    .map_err(crate::operation::converse_stream::ConverseStreamError::unhandled)?;
   95     86   
                let output = output.meta(generic);
   96     87   
                output.build()
   97     88   
            };
   98         -
            if tmp.message.is_none() {
   99         -
                tmp.message = _error_message;
  100         -
            }
  101     89   
            tmp
  102     90   
        }),
  103     91   
        "InternalServerException" => crate::operation::converse_stream::ConverseStreamError::InternalServerException({
  104     92   
            #[allow(unused_mut)]
  105     93   
            let mut tmp = {
  106     94   
                #[allow(unused_mut)]
  107     95   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
  108     96   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
  109     97   
                    .map_err(crate::operation::converse_stream::ConverseStreamError::unhandled)?;
  110     98   
                let output = output.meta(generic);
  111     99   
                output.build()
  112    100   
            };
  113         -
            if tmp.message.is_none() {
  114         -
                tmp.message = _error_message;
  115         -
            }
  116    101   
            tmp
  117    102   
        }),
  118    103   
        "ModelStreamErrorException" => crate::operation::converse_stream::ConverseStreamError::ModelStreamErrorException({
  119    104   
            #[allow(unused_mut)]
  120    105   
            let mut tmp = {
  121    106   
                #[allow(unused_mut)]
  122    107   
                let mut output = crate::types::error::builders::ModelStreamErrorExceptionBuilder::default();
  123    108   
                output = crate::protocol_serde::shape_model_stream_error_exception::de_model_stream_error_exception_json_err(_response_body, output)
  124    109   
                    .map_err(crate::operation::converse_stream::ConverseStreamError::unhandled)?;
  125    110   
                let output = output.meta(generic);
  126    111   
                output.build()
  127    112   
            };
  128         -
            if tmp.message.is_none() {
  129         -
                tmp.message = _error_message;
  130         -
            }
  131    113   
            tmp
  132    114   
        }),
  133    115   
        "ValidationException" => crate::operation::converse_stream::ConverseStreamError::ValidationException({
  134    116   
            #[allow(unused_mut)]
  135    117   
            let mut tmp = {
  136    118   
                #[allow(unused_mut)]
  137    119   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
  138    120   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  139    121   
                    .map_err(crate::operation::converse_stream::ConverseStreamError::unhandled)?;
  140    122   
                let output = output.meta(generic);
  141    123   
                output.build()
  142    124   
            };
  143         -
            if tmp.message.is_none() {
  144         -
                tmp.message = _error_message;
  145         -
            }
  146    125   
            tmp
  147    126   
        }),
  148    127   
        "ModelNotReadyException" => crate::operation::converse_stream::ConverseStreamError::ModelNotReadyException({
  149    128   
            #[allow(unused_mut)]
  150    129   
            let mut tmp = {
  151    130   
                #[allow(unused_mut)]
  152    131   
                let mut output = crate::types::error::builders::ModelNotReadyExceptionBuilder::default();
  153    132   
                output = crate::protocol_serde::shape_model_not_ready_exception::de_model_not_ready_exception_json_err(_response_body, output)
  154    133   
                    .map_err(crate::operation::converse_stream::ConverseStreamError::unhandled)?;
  155    134   
                let output = output.meta(generic);
  156    135   
                output.build()
  157    136   
            };
  158         -
            if tmp.message.is_none() {
  159         -
                tmp.message = _error_message;
  160         -
            }
  161    137   
            tmp
  162    138   
        }),
  163    139   
        "ModelErrorException" => crate::operation::converse_stream::ConverseStreamError::ModelErrorException({
  164    140   
            #[allow(unused_mut)]
  165    141   
            let mut tmp = {
  166    142   
                #[allow(unused_mut)]
  167    143   
                let mut output = crate::types::error::builders::ModelErrorExceptionBuilder::default();
  168    144   
                output = crate::protocol_serde::shape_model_error_exception::de_model_error_exception_json_err(_response_body, output)
  169    145   
                    .map_err(crate::operation::converse_stream::ConverseStreamError::unhandled)?;
  170    146   
                let output = output.meta(generic);
  171    147   
                output.build()
  172    148   
            };
  173         -
            if tmp.message.is_none() {
  174         -
                tmp.message = _error_message;
  175         -
            }
  176    149   
            tmp
  177    150   
        }),
  178    151   
        _ => crate::operation::converse_stream::ConverseStreamError::generic(generic),
  179    152   
    })
  180    153   
}
  181    154   
  182    155   
pub fn ser_converse_stream_input(
  183    156   
    input: &crate::operation::converse_stream::ConverseStreamInput,
  184    157   
) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
  185    158   
    let mut out = String::new();

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/protocol_serde/shape_invoke_model.rs

@@ -1,1 +185,158 @@
   20     20   
        "ModelTimeoutException" => crate::operation::invoke_model::InvokeModelError::ModelTimeoutException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ModelTimeoutExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_model_timeout_exception::de_model_timeout_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::invoke_model::InvokeModelError::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   
        "AccessDeniedException" => crate::operation::invoke_model::InvokeModelError::AccessDeniedException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::invoke_model::InvokeModelError::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   
        "ResourceNotFoundException" => crate::operation::invoke_model::InvokeModelError::ResourceNotFoundException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::invoke_model::InvokeModelError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "ThrottlingException" => crate::operation::invoke_model::InvokeModelError::ThrottlingException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::invoke_model::InvokeModelError::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   
        "InternalServerException" => crate::operation::invoke_model::InvokeModelError::InternalServerException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::invoke_model::InvokeModelError::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   
        "ValidationException" => crate::operation::invoke_model::InvokeModelError::ValidationException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
  100     85   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  101     86   
                    .map_err(crate::operation::invoke_model::InvokeModelError::unhandled)?;
  102     87   
                let output = output.meta(generic);
  103     88   
                output.build()
  104     89   
            };
  105         -
            if tmp.message.is_none() {
  106         -
                tmp.message = _error_message;
  107         -
            }
  108     90   
            tmp
  109     91   
        }),
  110     92   
        "ModelNotReadyException" => crate::operation::invoke_model::InvokeModelError::ModelNotReadyException({
  111     93   
            #[allow(unused_mut)]
  112     94   
            let mut tmp = {
  113     95   
                #[allow(unused_mut)]
  114     96   
                let mut output = crate::types::error::builders::ModelNotReadyExceptionBuilder::default();
  115     97   
                output = crate::protocol_serde::shape_model_not_ready_exception::de_model_not_ready_exception_json_err(_response_body, output)
  116     98   
                    .map_err(crate::operation::invoke_model::InvokeModelError::unhandled)?;
  117     99   
                let output = output.meta(generic);
  118    100   
                output.build()
  119    101   
            };
  120         -
            if tmp.message.is_none() {
  121         -
                tmp.message = _error_message;
  122         -
            }
  123    102   
            tmp
  124    103   
        }),
  125    104   
        "ModelErrorException" => crate::operation::invoke_model::InvokeModelError::ModelErrorException({
  126    105   
            #[allow(unused_mut)]
  127    106   
            let mut tmp = {
  128    107   
                #[allow(unused_mut)]
  129    108   
                let mut output = crate::types::error::builders::ModelErrorExceptionBuilder::default();
  130    109   
                output = crate::protocol_serde::shape_model_error_exception::de_model_error_exception_json_err(_response_body, output)
  131    110   
                    .map_err(crate::operation::invoke_model::InvokeModelError::unhandled)?;
  132    111   
                let output = output.meta(generic);
  133    112   
                output.build()
  134    113   
            };
  135         -
            if tmp.message.is_none() {
  136         -
                tmp.message = _error_message;
  137         -
            }
  138    114   
            tmp
  139    115   
        }),
  140    116   
        "ServiceQuotaExceededException" => crate::operation::invoke_model::InvokeModelError::ServiceQuotaExceededException({
  141    117   
            #[allow(unused_mut)]
  142    118   
            let mut tmp = {
  143    119   
                #[allow(unused_mut)]
  144    120   
                let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
  145    121   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
  146    122   
                    _response_body,
  147    123   
                    output,
  148    124   
                )
  149    125   
                .map_err(crate::operation::invoke_model::InvokeModelError::unhandled)?;
  150    126   
                let output = output.meta(generic);
  151    127   
                output.build()
  152    128   
            };
  153         -
            if tmp.message.is_none() {
  154         -
                tmp.message = _error_message;
  155         -
            }
  156    129   
            tmp
  157    130   
        }),
  158    131   
        _ => crate::operation::invoke_model::InvokeModelError::generic(generic),
  159    132   
    })
  160    133   
}
  161    134   
  162    135   
#[allow(clippy::unnecessary_wraps)]
  163    136   
pub fn de_invoke_model_http_response(
  164    137   
    _response_status: u16,
  165    138   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/protocol_serde/shape_invoke_model_with_response_stream.rs

@@ -36,36 +247,217 @@
   56     56   
        "ModelTimeoutException" => crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::ModelTimeoutException({
   57     57   
            #[allow(unused_mut)]
   58     58   
            let mut tmp = {
   59     59   
                #[allow(unused_mut)]
   60     60   
                let mut output = crate::types::error::builders::ModelTimeoutExceptionBuilder::default();
   61     61   
                output = crate::protocol_serde::shape_model_timeout_exception::de_model_timeout_exception_json_err(_response_body, output)
   62     62   
                    .map_err(crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::unhandled)?;
   63     63   
                let output = output.meta(generic);
   64     64   
                output.build()
   65     65   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     66   
            tmp
   70     67   
        }),
   71     68   
        "AccessDeniedException" => crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::AccessDeniedException({
   72     69   
            #[allow(unused_mut)]
   73     70   
            let mut tmp = {
   74     71   
                #[allow(unused_mut)]
   75     72   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   76     73   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   77     74   
                    .map_err(crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::unhandled)?;
   78     75   
                let output = output.meta(generic);
   79     76   
                output.build()
   80     77   
            };
   81         -
            if tmp.message.is_none() {
   82         -
                tmp.message = _error_message;
   83         -
            }
   84     78   
            tmp
   85     79   
        }),
   86     80   
        "ResourceNotFoundException" => {
   87     81   
            crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::ResourceNotFoundException({
   88     82   
                #[allow(unused_mut)]
   89     83   
                let mut tmp = {
   90     84   
                    #[allow(unused_mut)]
   91     85   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   92     86   
                    output =
   93     87   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   94     88   
                            .map_err(crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::unhandled)?;
   95     89   
                    let output = output.meta(generic);
   96     90   
                    output.build()
   97     91   
                };
   98         -
                if tmp.message.is_none() {
   99         -
                    tmp.message = _error_message;
  100         -
                }
  101     92   
                tmp
  102     93   
            })
  103     94   
        }
  104     95   
        "ThrottlingException" => crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::ThrottlingException({
  105     96   
            #[allow(unused_mut)]
  106     97   
            let mut tmp = {
  107     98   
                #[allow(unused_mut)]
  108     99   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
  109    100   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
  110    101   
                    .map_err(crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::unhandled)?;
  111    102   
                let output = output.meta(generic);
  112    103   
                output.build()
  113    104   
            };
  114         -
            if tmp.message.is_none() {
  115         -
                tmp.message = _error_message;
  116         -
            }
  117    105   
            tmp
  118    106   
        }),
  119    107   
        "InternalServerException" => {
  120    108   
            crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::InternalServerException({
  121    109   
                #[allow(unused_mut)]
  122    110   
                let mut tmp = {
  123    111   
                    #[allow(unused_mut)]
  124    112   
                    let mut output = crate::types::error::builders::InternalServerExceptionBuilder::default();
  125    113   
                    output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
  126    114   
                        .map_err(crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::unhandled)?;
  127    115   
                    let output = output.meta(generic);
  128    116   
                    output.build()
  129    117   
                };
  130         -
                if tmp.message.is_none() {
  131         -
                    tmp.message = _error_message;
  132         -
                }
  133    118   
                tmp
  134    119   
            })
  135    120   
        }
  136    121   
        "ModelStreamErrorException" => {
  137    122   
            crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::ModelStreamErrorException({
  138    123   
                #[allow(unused_mut)]
  139    124   
                let mut tmp = {
  140    125   
                    #[allow(unused_mut)]
  141    126   
                    let mut output = crate::types::error::builders::ModelStreamErrorExceptionBuilder::default();
  142    127   
                    output =
  143    128   
                        crate::protocol_serde::shape_model_stream_error_exception::de_model_stream_error_exception_json_err(_response_body, output)
  144    129   
                            .map_err(crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::unhandled)?;
  145    130   
                    let output = output.meta(generic);
  146    131   
                    output.build()
  147    132   
                };
  148         -
                if tmp.message.is_none() {
  149         -
                    tmp.message = _error_message;
  150         -
                }
  151    133   
                tmp
  152    134   
            })
  153    135   
        }
  154    136   
        "ValidationException" => crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::ValidationException({
  155    137   
            #[allow(unused_mut)]
  156    138   
            let mut tmp = {
  157    139   
                #[allow(unused_mut)]
  158    140   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
  159    141   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  160    142   
                    .map_err(crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::unhandled)?;
  161    143   
                let output = output.meta(generic);
  162    144   
                output.build()
  163    145   
            };
  164         -
            if tmp.message.is_none() {
  165         -
                tmp.message = _error_message;
  166         -
            }
  167    146   
            tmp
  168    147   
        }),
  169    148   
        "ModelNotReadyException" => {
  170    149   
            crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::ModelNotReadyException({
  171    150   
                #[allow(unused_mut)]
  172    151   
                let mut tmp = {
  173    152   
                    #[allow(unused_mut)]
  174    153   
                    let mut output = crate::types::error::builders::ModelNotReadyExceptionBuilder::default();
  175    154   
                    output = crate::protocol_serde::shape_model_not_ready_exception::de_model_not_ready_exception_json_err(_response_body, output)
  176    155   
                        .map_err(crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::unhandled)?;
  177    156   
                    let output = output.meta(generic);
  178    157   
                    output.build()
  179    158   
                };
  180         -
                if tmp.message.is_none() {
  181         -
                    tmp.message = _error_message;
  182         -
                }
  183    159   
                tmp
  184    160   
            })
  185    161   
        }
  186    162   
        "ModelErrorException" => crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::ModelErrorException({
  187    163   
            #[allow(unused_mut)]
  188    164   
            let mut tmp = {
  189    165   
                #[allow(unused_mut)]
  190    166   
                let mut output = crate::types::error::builders::ModelErrorExceptionBuilder::default();
  191    167   
                output = crate::protocol_serde::shape_model_error_exception::de_model_error_exception_json_err(_response_body, output)
  192    168   
                    .map_err(crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::unhandled)?;
  193    169   
                let output = output.meta(generic);
  194    170   
                output.build()
  195    171   
            };
  196         -
            if tmp.message.is_none() {
  197         -
                tmp.message = _error_message;
  198         -
            }
  199    172   
            tmp
  200    173   
        }),
  201    174   
        "ServiceQuotaExceededException" => {
  202    175   
            crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::ServiceQuotaExceededException({
  203    176   
                #[allow(unused_mut)]
  204    177   
                let mut tmp = {
  205    178   
                    #[allow(unused_mut)]
  206    179   
                    let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
  207    180   
                    output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
  208    181   
                        _response_body,
  209    182   
                        output,
  210    183   
                    )
  211    184   
                    .map_err(crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::unhandled)?;
  212    185   
                    let output = output.meta(generic);
  213    186   
                    output.build()
  214    187   
                };
  215         -
                if tmp.message.is_none() {
  216         -
                    tmp.message = _error_message;
  217         -
                }
  218    188   
                tmp
  219    189   
            })
  220    190   
        }
  221    191   
        _ => crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::generic(generic),
  222    192   
    })
  223    193   
}
  224    194   
  225    195   
pub fn ser_invoke_model_with_response_stream_headers(
  226    196   
    input: &crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamInput,
  227    197   
    mut builder: ::http::request::Builder,

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

@@ -1,1 +107,95 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::associate_kms_key::AssociateKmsKeyError::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::associate_kms_key::AssociateKmsKeyError::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::associate_kms_key::AssociateKmsKeyError::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::associate_kms_key::AssociateKmsKeyError::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::associate_kms_key::AssociateKmsKeyError::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::associate_kms_key::AssociateKmsKeyError::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::associate_kms_key::AssociateKmsKeyError::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::associate_kms_key::AssociateKmsKeyError::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::associate_kms_key::AssociateKmsKeyError::generic(generic),
   82     70   
    })
   83     71   
}
   84     72   
   85     73   
#[allow(clippy::unnecessary_wraps)]
   86     74   
pub fn de_associate_kms_key_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_cancel_export_task.rs

@@ -1,1 +107,95 @@
   20     20   
        "InvalidOperationException" => crate::operation::cancel_export_task::CancelExportTaskError::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::cancel_export_task::CancelExportTaskError::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::cancel_export_task::CancelExportTaskError::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::cancel_export_task::CancelExportTaskError::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::cancel_export_task::CancelExportTaskError::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::cancel_export_task::CancelExportTaskError::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::cancel_export_task::CancelExportTaskError::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::cancel_export_task::CancelExportTaskError::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::cancel_export_task::CancelExportTaskError::generic(generic),
   82     70   
    })
   83     71   
}
   84     72   
   85     73   
#[allow(clippy::unnecessary_wraps)]
   86     74   
pub fn de_cancel_export_task_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_create_delivery.rs

@@ -1,1 +156,135 @@
   20     20   
        "ThrottlingException" => crate::operation::create_delivery::CreateDeliveryError::ThrottlingException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::create_delivery::CreateDeliveryError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "ConflictException" => crate::operation::create_delivery::CreateDeliveryError::ConflictException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::create_delivery::CreateDeliveryError::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   
        "ValidationException" => crate::operation::create_delivery::CreateDeliveryError::ValidationException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::create_delivery::CreateDeliveryError::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   
        "ResourceNotFoundException" => crate::operation::create_delivery::CreateDeliveryError::ResourceNotFoundException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::create_delivery::CreateDeliveryError::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   
        "AccessDeniedException" => crate::operation::create_delivery::CreateDeliveryError::AccessDeniedException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::AccessDeniedExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::create_delivery::CreateDeliveryError::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::create_delivery::CreateDeliveryError::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::create_delivery::CreateDeliveryError::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   
        "ServiceQuotaExceededException" => crate::operation::create_delivery::CreateDeliveryError::ServiceQuotaExceededException({
  112     94   
            #[allow(unused_mut)]
  113     95   
            let mut tmp = {
  114     96   
                #[allow(unused_mut)]
  115     97   
                let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
  116     98   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
  117     99   
                    _response_body,
  118    100   
                    output,
  119    101   
                )
  120    102   
                .map_err(crate::operation::create_delivery::CreateDeliveryError::unhandled)?;
  121    103   
                let output = output.meta(generic);
  122    104   
                output.build()
  123    105   
            };
  124         -
            if tmp.message.is_none() {
  125         -
                tmp.message = _error_message;
  126         -
            }
  127    106   
            tmp
  128    107   
        }),
  129    108   
        _ => crate::operation::create_delivery::CreateDeliveryError::generic(generic),
  130    109   
    })
  131    110   
}
  132    111   
  133    112   
#[allow(clippy::unnecessary_wraps)]
  134    113   
pub fn de_create_delivery_http_response(
  135    114   
    _response_status: u16,
  136    115   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +141,123 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::create_export_task::CreateExportTaskError::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::create_export_task::CreateExportTaskError::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::create_export_task::CreateExportTaskError::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::create_export_task::CreateExportTaskError::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   
        "LimitExceededException" => crate::operation::create_export_task::CreateExportTaskError::LimitExceededException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::create_export_task::CreateExportTaskError::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   
        "OperationAbortedException" => crate::operation::create_export_task::CreateExportTaskError::OperationAbortedException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::OperationAbortedExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_operation_aborted_exception::de_operation_aborted_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::create_export_task::CreateExportTaskError::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::create_export_task::CreateExportTaskError::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::create_export_task::CreateExportTaskError::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   
        "ResourceAlreadyExistsException" => crate::operation::create_export_task::CreateExportTaskError::ResourceAlreadyExistsException({
   97     82   
            #[allow(unused_mut)]
   98     83   
            let mut tmp = {
   99     84   
                #[allow(unused_mut)]
  100     85   
                let mut output = crate::types::error::builders::ResourceAlreadyExistsExceptionBuilder::default();
  101     86   
                output = crate::protocol_serde::shape_resource_already_exists_exception::de_resource_already_exists_exception_json_err(
  102     87   
                    _response_body,
  103     88   
                    output,
  104     89   
                )
  105     90   
                .map_err(crate::operation::create_export_task::CreateExportTaskError::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::create_export_task::CreateExportTaskError::generic(generic),
  115     97   
    })
  116     98   
}
  117     99   
  118    100   
#[allow(clippy::unnecessary_wraps)]
  119    101   
pub fn de_create_export_task_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_create_log_anomaly_detector.rs

@@ -7,7 +130,115 @@
   27     27   
        "ResourceNotFoundException" => crate::operation::create_log_anomaly_detector::CreateLogAnomalyDetectorError::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::create_log_anomaly_detector::CreateLogAnomalyDetectorError::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::create_log_anomaly_detector::CreateLogAnomalyDetectorError::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::create_log_anomaly_detector::CreateLogAnomalyDetectorError::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   
        "LimitExceededException" => crate::operation::create_log_anomaly_detector::CreateLogAnomalyDetectorError::LimitExceededException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::create_log_anomaly_detector::CreateLogAnomalyDetectorError::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   
        "OperationAbortedException" => crate::operation::create_log_anomaly_detector::CreateLogAnomalyDetectorError::OperationAbortedException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::OperationAbortedExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_operation_aborted_exception::de_operation_aborted_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::create_log_anomaly_detector::CreateLogAnomalyDetectorError::unhandled)?;
   79     70   
                let output = output.meta(generic);
   80     71   
                output.build()
   81     72   
            };
   82         -
            if tmp.message.is_none() {
   83         -
                tmp.message = _error_message;
   84         -
            }
   85     73   
            tmp
   86     74   
        }),
   87     75   
        "ServiceUnavailableException" => crate::operation::create_log_anomaly_detector::CreateLogAnomalyDetectorError::ServiceUnavailableException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   92     80   
                output =
   93     81   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   94     82   
                        .map_err(crate::operation::create_log_anomaly_detector::CreateLogAnomalyDetectorError::unhandled)?;
   95     83   
                let output = output.meta(generic);
   96     84   
                output.build()
   97     85   
            };
   98         -
            if tmp.message.is_none() {
   99         -
                tmp.message = _error_message;
  100         -
            }
  101     86   
            tmp
  102     87   
        }),
  103     88   
        _ => crate::operation::create_log_anomaly_detector::CreateLogAnomalyDetectorError::generic(generic),
  104     89   
    })
  105     90   
}
  106     91   
  107     92   
#[allow(clippy::unnecessary_wraps)]
  108     93   
pub fn de_create_log_anomaly_detector_http_response(
  109     94   
    _response_status: u16,
  110     95   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +125,110 @@
   20     20   
        "InvalidParameterException" => crate::operation::create_log_group::CreateLogGroupError::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::create_log_group::CreateLogGroupError::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   
        "LimitExceededException" => crate::operation::create_log_group::CreateLogGroupError::LimitExceededException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::create_log_group::CreateLogGroupError::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::create_log_group::CreateLogGroupError::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::create_log_group::CreateLogGroupError::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::create_log_group::CreateLogGroupError::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::create_log_group::CreateLogGroupError::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   
        "ResourceAlreadyExistsException" => crate::operation::create_log_group::CreateLogGroupError::ResourceAlreadyExistsException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::ResourceAlreadyExistsExceptionBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_resource_already_exists_exception::de_resource_already_exists_exception_json_err(
   87     75   
                    _response_body,
   88     76   
                    output,
   89     77   
                )
   90     78   
                .map_err(crate::operation::create_log_group::CreateLogGroupError::unhandled)?;
   91     79   
                let output = output.meta(generic);
   92     80   
                output.build()
   93     81   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     82   
            tmp
   98     83   
        }),
   99     84   
        _ => crate::operation::create_log_group::CreateLogGroupError::generic(generic),
  100     85   
    })
  101     86   
}
  102     87   
  103     88   
#[allow(clippy::unnecessary_wraps)]
  104     89   
pub fn de_create_log_group_http_response(
  105     90   
    _response_status: u16,
  106     91   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +110,98 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::create_log_stream::CreateLogStreamError::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::create_log_stream::CreateLogStreamError::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::create_log_stream::CreateLogStreamError::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::create_log_stream::CreateLogStreamError::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::create_log_stream::CreateLogStreamError::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::create_log_stream::CreateLogStreamError::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   
        "ResourceAlreadyExistsException" => crate::operation::create_log_stream::CreateLogStreamError::ResourceAlreadyExistsException({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::ResourceAlreadyExistsExceptionBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_resource_already_exists_exception::de_resource_already_exists_exception_json_err(
   72     63   
                    _response_body,
   73     64   
                    output,
   74     65   
                )
   75     66   
                .map_err(crate::operation::create_log_stream::CreateLogStreamError::unhandled)?;
   76     67   
                let output = output.meta(generic);
   77     68   
                output.build()
   78     69   
            };
   79         -
            if tmp.message.is_none() {
   80         -
                tmp.message = _error_message;
   81         -
            }
   82     70   
            tmp
   83     71   
        }),
   84     72   
        _ => crate::operation::create_log_stream::CreateLogStreamError::generic(generic),
   85     73   
    })
   86     74   
}
   87     75   
   88     76   
#[allow(clippy::unnecessary_wraps)]
   89     77   
pub fn de_create_log_stream_http_response(
   90     78   
    _response_status: u16,
   91     79   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

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

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

@@ -3,3 +112,100 @@
   23     23   
        "ResourceNotFoundException" => crate::operation::delete_data_protection_policy::DeleteDataProtectionPolicyError::ResourceNotFoundException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::delete_data_protection_policy::DeleteDataProtectionPolicyError::unhandled)?;
   30     30   
                let output = output.meta(generic);
   31     31   
                output.build()
   32     32   
            };
   33         -
            if tmp.message.is_none() {
   34         -
                tmp.message = _error_message;
   35         -
            }
   36     33   
            tmp
   37     34   
        }),
   38     35   
        "InvalidParameterException" => crate::operation::delete_data_protection_policy::DeleteDataProtectionPolicyError::InvalidParameterException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::delete_data_protection_policy::DeleteDataProtectionPolicyError::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   
        "OperationAbortedException" => crate::operation::delete_data_protection_policy::DeleteDataProtectionPolicyError::OperationAbortedException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::OperationAbortedExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_operation_aborted_exception::de_operation_aborted_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::delete_data_protection_policy::DeleteDataProtectionPolicyError::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   
        "ServiceUnavailableException" => {
   69     60   
            crate::operation::delete_data_protection_policy::DeleteDataProtectionPolicyError::ServiceUnavailableException({
   70     61   
                #[allow(unused_mut)]
   71     62   
                let mut tmp = {
   72     63   
                    #[allow(unused_mut)]
   73     64   
                    let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   74     65   
                    output =
   75     66   
                        crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   76     67   
                            .map_err(crate::operation::delete_data_protection_policy::DeleteDataProtectionPolicyError::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   
        _ => crate::operation::delete_data_protection_policy::DeleteDataProtectionPolicyError::generic(generic),
   87     75   
    })
   88     76   
}
   89     77   
   90     78   
#[allow(clippy::unnecessary_wraps)]
   91     79   
pub fn de_delete_data_protection_policy_http_response(
   92     80   
    _response_status: u16,

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

@@ -1,1 +140,122 @@
   20     20   
        "ThrottlingException" => crate::operation::delete_delivery::DeleteDeliveryError::ThrottlingException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::delete_delivery::DeleteDeliveryError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "ConflictException" => crate::operation::delete_delivery::DeleteDeliveryError::ConflictException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::delete_delivery::DeleteDeliveryError::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   
        "ValidationException" => crate::operation::delete_delivery::DeleteDeliveryError::ValidationException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::delete_delivery::DeleteDeliveryError::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   
        "ResourceNotFoundException" => crate::operation::delete_delivery::DeleteDeliveryError::ResourceNotFoundException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::delete_delivery::DeleteDeliveryError::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::delete_delivery::DeleteDeliveryError::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::delete_delivery::DeleteDeliveryError::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   
        "ServiceQuotaExceededException" => crate::operation::delete_delivery::DeleteDeliveryError::ServiceQuotaExceededException({
   97     82   
            #[allow(unused_mut)]
   98     83   
            let mut tmp = {
   99     84   
                #[allow(unused_mut)]
  100     85   
                let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
  101     86   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
  102     87   
                    _response_body,
  103     88   
                    output,
  104     89   
                )
  105     90   
                .map_err(crate::operation::delete_delivery::DeleteDeliveryError::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::delete_delivery::DeleteDeliveryError::generic(generic),
  115     97   
    })
  116     98   
}
  117     99   
  118    100   
#[allow(clippy::unnecessary_wraps)]
  119    101   
pub fn de_delete_delivery_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_delete_delivery_destination.rs

@@ -7,7 +151,133 @@
   27     27   
        "ThrottlingException" => crate::operation::delete_delivery_destination::DeleteDeliveryDestinationError::ThrottlingException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::delete_delivery_destination::DeleteDeliveryDestinationError::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   
        "ConflictException" => crate::operation::delete_delivery_destination::DeleteDeliveryDestinationError::ConflictException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::delete_delivery_destination::DeleteDeliveryDestinationError::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   
        "ValidationException" => crate::operation::delete_delivery_destination::DeleteDeliveryDestinationError::ValidationException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::delete_delivery_destination::DeleteDeliveryDestinationError::unhandled)?;
   64     58   
                let output = output.meta(generic);
   65     59   
                output.build()
   66     60   
            };
   67         -
            if tmp.message.is_none() {
   68         -
                tmp.message = _error_message;
   69         -
            }
   70     61   
            tmp
   71     62   
        }),
   72     63   
        "ResourceNotFoundException" => crate::operation::delete_delivery_destination::DeleteDeliveryDestinationError::ResourceNotFoundException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::delete_delivery_destination::DeleteDeliveryDestinationError::unhandled)?;
   79     70   
                let output = output.meta(generic);
   80     71   
                output.build()
   81     72   
            };
   82         -
            if tmp.message.is_none() {
   83         -
                tmp.message = _error_message;
   84         -
            }
   85     73   
            tmp
   86     74   
        }),
   87     75   
        "ServiceUnavailableException" => {
   88     76   
            crate::operation::delete_delivery_destination::DeleteDeliveryDestinationError::ServiceUnavailableException({
   89     77   
                #[allow(unused_mut)]
   90     78   
                let mut tmp = {
   91     79   
                    #[allow(unused_mut)]
   92     80   
                    let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   93     81   
                    output =
   94     82   
                        crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   95     83   
                            .map_err(crate::operation::delete_delivery_destination::DeleteDeliveryDestinationError::unhandled)?;
   96     84   
                    let output = output.meta(generic);
   97     85   
                    output.build()
   98     86   
                };
   99         -
                if tmp.message.is_none() {
  100         -
                    tmp.message = _error_message;
  101         -
                }
  102     87   
                tmp
  103     88   
            })
  104     89   
        }
  105     90   
        "ServiceQuotaExceededException" => {
  106     91   
            crate::operation::delete_delivery_destination::DeleteDeliveryDestinationError::ServiceQuotaExceededException({
  107     92   
                #[allow(unused_mut)]
  108     93   
                let mut tmp = {
  109     94   
                    #[allow(unused_mut)]
  110     95   
                    let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
  111     96   
                    output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
  112     97   
                        _response_body,
  113     98   
                        output,
  114     99   
                    )
  115    100   
                    .map_err(crate::operation::delete_delivery_destination::DeleteDeliveryDestinationError::unhandled)?;
  116    101   
                    let output = output.meta(generic);
  117    102   
                    output.build()
  118    103   
                };
  119         -
                if tmp.message.is_none() {
  120         -
                    tmp.message = _error_message;
  121         -
                }
  122    104   
                tmp
  123    105   
            })
  124    106   
        }
  125    107   
        _ => crate::operation::delete_delivery_destination::DeleteDeliveryDestinationError::generic(generic),
  126    108   
    })
  127    109   
}
  128    110   
  129    111   
#[allow(clippy::unnecessary_wraps)]
  130    112   
pub fn de_delete_delivery_destination_http_response(
  131    113   
    _response_status: u16,