AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05 (ignoring whitespace)

Files changed:

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

@@ -3,3 +96,87 @@
   23     23   
        "ResourceNotFoundException" => crate::operation::list_tags_for_resource::ListTagsForResourceError::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::list_tags_for_resource::ListTagsForResourceError::unhandled)?;
   30     30   
                let output = output.meta(generic);
   31     31   
                output.build()
   32     32   
            };
   33         -
            if tmp.message.is_none() {
   34         -
                tmp.message = _error_message;
   35         -
            }
   36     33   
            tmp
   37     34   
        }),
   38     35   
        "InvalidParameterException" => crate::operation::list_tags_for_resource::ListTagsForResourceError::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::list_tags_for_resource::ListTagsForResourceError::unhandled)?;
   45     42   
                let output = output.meta(generic);
   46     43   
                output.build()
   47     44   
            };
   48         -
            if tmp.message.is_none() {
   49         -
                tmp.message = _error_message;
   50         -
            }
   51     45   
            tmp
   52     46   
        }),
   53     47   
        "ServiceUnavailableException" => crate::operation::list_tags_for_resource::ListTagsForResourceError::ServiceUnavailableException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   58     52   
                output =
   59     53   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   60     54   
                        .map_err(crate::operation::list_tags_for_resource::ListTagsForResourceError::unhandled)?;
   61     55   
                let output = output.meta(generic);
   62     56   
                output.build()
   63     57   
            };
   64         -
            if tmp.message.is_none() {
   65         -
                tmp.message = _error_message;
   66         -
            }
   67     58   
            tmp
   68     59   
        }),
   69     60   
        _ => crate::operation::list_tags_for_resource::ListTagsForResourceError::generic(generic),
   70     61   
    })
   71     62   
}
   72     63   
   73     64   
#[allow(clippy::unnecessary_wraps)]
   74     65   
pub fn de_list_tags_for_resource_http_response(
   75     66   
    _response_status: u16,
   76     67   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +79,73 @@
   21     21   
        "ResourceNotFoundException" => crate::operation::list_tags_log_group::ListTagsLogGroupError::ResourceNotFoundException({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::list_tags_log_group::ListTagsLogGroupError::unhandled)?;
   28     28   
                let output = output.meta(generic);
   29     29   
                output.build()
   30     30   
            };
   31         -
            if tmp.message.is_none() {
   32         -
                tmp.message = _error_message;
   33         -
            }
   34     31   
            tmp
   35     32   
        }),
   36     33   
        "ServiceUnavailableException" => crate::operation::list_tags_log_group::ListTagsLogGroupError::ServiceUnavailableException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   41     38   
                output =
   42     39   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   43     40   
                        .map_err(crate::operation::list_tags_log_group::ListTagsLogGroupError::unhandled)?;
   44     41   
                let output = output.meta(generic);
   45     42   
                output.build()
   46     43   
            };
   47         -
            if tmp.message.is_none() {
   48         -
                tmp.message = _error_message;
   49         -
            }
   50     44   
            tmp
   51     45   
        }),
   52     46   
        _ => crate::operation::list_tags_log_group::ListTagsLogGroupError::generic(generic),
   53     47   
    })
   54     48   
}
   55     49   
   56     50   
#[allow(clippy::unnecessary_wraps)]
   57     51   
pub fn de_list_tags_log_group_http_response(
   58     52   
    _response_status: u16,
   59     53   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +108,96 @@
   20     20   
        "InvalidParameterException" => crate::operation::put_account_policy::PutAccountPolicyError::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::put_account_policy::PutAccountPolicyError::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::put_account_policy::PutAccountPolicyError::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::put_account_policy::PutAccountPolicyError::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::put_account_policy::PutAccountPolicyError::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::put_account_policy::PutAccountPolicyError::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::put_account_policy::PutAccountPolicyError::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::put_account_policy::PutAccountPolicyError::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::put_account_policy::PutAccountPolicyError::generic(generic),
   82     70   
    })
   83     71   
}
   84     72   
   85     73   
#[allow(clippy::unnecessary_wraps)]
   86     74   
pub fn de_put_account_policy_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_put_data_protection_policy.rs

@@ -7,7 +130,115 @@
   27     27   
        "ResourceNotFoundException" => crate::operation::put_data_protection_policy::PutDataProtectionPolicyError::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::put_data_protection_policy::PutDataProtectionPolicyError::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::put_data_protection_policy::PutDataProtectionPolicyError::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::put_data_protection_policy::PutDataProtectionPolicyError::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::put_data_protection_policy::PutDataProtectionPolicyError::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::put_data_protection_policy::PutDataProtectionPolicyError::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::put_data_protection_policy::PutDataProtectionPolicyError::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::put_data_protection_policy::PutDataProtectionPolicyError::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::put_data_protection_policy::PutDataProtectionPolicyError::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::put_data_protection_policy::PutDataProtectionPolicyError::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::put_data_protection_policy::PutDataProtectionPolicyError::generic(generic),
  104     89   
    })
  105     90   
}
  106     91   
  107     92   
#[allow(clippy::unnecessary_wraps)]
  108     93   
pub fn de_put_data_protection_policy_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_put_delivery_destination.rs

@@ -7,7 +148,130 @@
   27     27   
        "ThrottlingException" => crate::operation::put_delivery_destination::PutDeliveryDestinationError::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::put_delivery_destination::PutDeliveryDestinationError::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::put_delivery_destination::PutDeliveryDestinationError::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::put_delivery_destination::PutDeliveryDestinationError::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::put_delivery_destination::PutDeliveryDestinationError::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::put_delivery_destination::PutDeliveryDestinationError::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::put_delivery_destination::PutDeliveryDestinationError::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::put_delivery_destination::PutDeliveryDestinationError::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::put_delivery_destination::PutDeliveryDestinationError::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::put_delivery_destination::PutDeliveryDestinationError::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   
        "ServiceQuotaExceededException" => crate::operation::put_delivery_destination::PutDeliveryDestinationError::ServiceQuotaExceededException({
  104     89   
            #[allow(unused_mut)]
  105     90   
            let mut tmp = {
  106     91   
                #[allow(unused_mut)]
  107     92   
                let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
  108     93   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
  109     94   
                    _response_body,
  110     95   
                    output,
  111     96   
                )
  112     97   
                .map_err(crate::operation::put_delivery_destination::PutDeliveryDestinationError::unhandled)?;
  113     98   
                let output = output.meta(generic);
  114     99   
                output.build()
  115    100   
            };
  116         -
            if tmp.message.is_none() {
  117         -
                tmp.message = _error_message;
  118         -
            }
  119    101   
            tmp
  120    102   
        }),
  121    103   
        _ => crate::operation::put_delivery_destination::PutDeliveryDestinationError::generic(generic),
  122    104   
    })
  123    105   
}
  124    106   
  125    107   
#[allow(clippy::unnecessary_wraps)]
  126    108   
pub fn de_put_delivery_destination_http_response(
  127    109   
    _response_status: u16,
  128    110   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +115,103 @@
   23     23   
        "ConflictException" => crate::operation::put_delivery_destination_policy::PutDeliveryDestinationPolicyError::ConflictException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::put_delivery_destination_policy::PutDeliveryDestinationPolicyError::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   
        "ValidationException" => crate::operation::put_delivery_destination_policy::PutDeliveryDestinationPolicyError::ValidationException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::put_delivery_destination_policy::PutDeliveryDestinationPolicyError::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   
        "ResourceNotFoundException" => {
   54     48   
            crate::operation::put_delivery_destination_policy::PutDeliveryDestinationPolicyError::ResourceNotFoundException({
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut tmp = {
   57     51   
                    #[allow(unused_mut)]
   58     52   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   59     53   
                    output =
   60     54   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   61     55   
                            .map_err(crate::operation::put_delivery_destination_policy::PutDeliveryDestinationPolicyError::unhandled)?;
   62     56   
                    let output = output.meta(generic);
   63     57   
                    output.build()
   64     58   
                };
   65         -
                if tmp.message.is_none() {
   66         -
                    tmp.message = _error_message;
   67         -
                }
   68     59   
                tmp
   69     60   
            })
   70     61   
        }
   71     62   
        "ServiceUnavailableException" => {
   72     63   
            crate::operation::put_delivery_destination_policy::PutDeliveryDestinationPolicyError::ServiceUnavailableException({
   73     64   
                #[allow(unused_mut)]
   74     65   
                let mut tmp = {
   75     66   
                    #[allow(unused_mut)]
   76     67   
                    let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   77     68   
                    output =
   78     69   
                        crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   79     70   
                            .map_err(crate::operation::put_delivery_destination_policy::PutDeliveryDestinationPolicyError::unhandled)?;
   80     71   
                    let output = output.meta(generic);
   81     72   
                    output.build()
   82     73   
                };
   83         -
                if tmp.message.is_none() {
   84         -
                    tmp.message = _error_message;
   85         -
                }
   86     74   
                tmp
   87     75   
            })
   88     76   
        }
   89     77   
        _ => crate::operation::put_delivery_destination_policy::PutDeliveryDestinationPolicyError::generic(generic),
   90     78   
    })
   91     79   
}
   92     80   
   93     81   
#[allow(clippy::unnecessary_wraps)]
   94     82   
pub fn de_put_delivery_destination_policy_http_response(
   95     83   
    _response_status: u16,

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

@@ -1,1 +142,124 @@
   21     21   
        "ThrottlingException" => crate::operation::put_delivery_source::PutDeliverySourceError::ThrottlingException({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::put_delivery_source::PutDeliverySourceError::unhandled)?;
   28     28   
                let output = output.meta(generic);
   29     29   
                output.build()
   30     30   
            };
   31         -
            if tmp.message.is_none() {
   32         -
                tmp.message = _error_message;
   33         -
            }
   34     31   
            tmp
   35     32   
        }),
   36     33   
        "ConflictException" => crate::operation::put_delivery_source::PutDeliverySourceError::ConflictException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::put_delivery_source::PutDeliverySourceError::unhandled)?;
   43     40   
                let output = output.meta(generic);
   44     41   
                output.build()
   45     42   
            };
   46         -
            if tmp.message.is_none() {
   47         -
                tmp.message = _error_message;
   48         -
            }
   49     43   
            tmp
   50     44   
        }),
   51     45   
        "ValidationException" => crate::operation::put_delivery_source::PutDeliverySourceError::ValidationException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::put_delivery_source::PutDeliverySourceError::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   
        "ResourceNotFoundException" => crate::operation::put_delivery_source::PutDeliverySourceError::ResourceNotFoundException({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::put_delivery_source::PutDeliverySourceError::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   
        "ServiceUnavailableException" => crate::operation::put_delivery_source::PutDeliverySourceError::ServiceUnavailableException({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   86     74   
                output =
   87     75   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   88     76   
                        .map_err(crate::operation::put_delivery_source::PutDeliverySourceError::unhandled)?;
   89     77   
                let output = output.meta(generic);
   90     78   
                output.build()
   91     79   
            };
   92         -
            if tmp.message.is_none() {
   93         -
                tmp.message = _error_message;
   94         -
            }
   95     80   
            tmp
   96     81   
        }),
   97     82   
        "ServiceQuotaExceededException" => crate::operation::put_delivery_source::PutDeliverySourceError::ServiceQuotaExceededException({
   98     83   
            #[allow(unused_mut)]
   99     84   
            let mut tmp = {
  100     85   
                #[allow(unused_mut)]
  101     86   
                let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
  102     87   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
  103     88   
                    _response_body,
  104     89   
                    output,
  105     90   
                )
  106     91   
                .map_err(crate::operation::put_delivery_source::PutDeliverySourceError::unhandled)?;
  107     92   
                let output = output.meta(generic);
  108     93   
                output.build()
  109     94   
            };
  110         -
            if tmp.message.is_none() {
  111         -
                tmp.message = _error_message;
  112         -
            }
  113     95   
            tmp
  114     96   
        }),
  115     97   
        _ => crate::operation::put_delivery_source::PutDeliverySourceError::generic(generic),
  116     98   
    })
  117     99   
}
  118    100   
  119    101   
#[allow(clippy::unnecessary_wraps)]
  120    102   
pub fn de_put_delivery_source_http_response(
  121    103   
    _response_status: u16,
  122    104   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +93,84 @@
   20     20   
        "InvalidParameterException" => crate::operation::put_destination::PutDestinationError::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::put_destination::PutDestinationError::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   
        "OperationAbortedException" => crate::operation::put_destination::PutDestinationError::OperationAbortedException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::OperationAbortedExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_operation_aborted_exception::de_operation_aborted_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::put_destination::PutDestinationError::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::put_destination::PutDestinationError::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::put_destination::PutDestinationError::unhandled)?;
   58     52   
                let output = output.meta(generic);
   59     53   
                output.build()
   60     54   
            };
   61         -
            if tmp.message.is_none() {
   62         -
                tmp.message = _error_message;
   63         -
            }
   64     55   
            tmp
   65     56   
        }),
   66     57   
        _ => crate::operation::put_destination::PutDestinationError::generic(generic),
   67     58   
    })
   68     59   
}
   69     60   
   70     61   
#[allow(clippy::unnecessary_wraps)]
   71     62   
pub fn de_put_destination_http_response(
   72     63   
    _response_status: u16,
   73     64   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +96,87 @@
   23     23   
        "InvalidParameterException" => crate::operation::put_destination_policy::PutDestinationPolicyError::InvalidParameterException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::put_destination_policy::PutDestinationPolicyError::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   
        "OperationAbortedException" => crate::operation::put_destination_policy::PutDestinationPolicyError::OperationAbortedException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::OperationAbortedExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_operation_aborted_exception::de_operation_aborted_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::put_destination_policy::PutDestinationPolicyError::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   
        "ServiceUnavailableException" => crate::operation::put_destination_policy::PutDestinationPolicyError::ServiceUnavailableException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   58     52   
                output =
   59     53   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   60     54   
                        .map_err(crate::operation::put_destination_policy::PutDestinationPolicyError::unhandled)?;
   61     55   
                let output = output.meta(generic);
   62     56   
                output.build()
   63     57   
            };
   64         -
            if tmp.message.is_none() {
   65         -
                tmp.message = _error_message;
   66         -
            }
   67     58   
            tmp
   68     59   
        }),
   69     60   
        _ => crate::operation::put_destination_policy::PutDestinationPolicyError::generic(generic),
   70     61   
    })
   71     62   
}
   72     63   
   73     64   
#[allow(clippy::unnecessary_wraps)]
   74     65   
pub fn de_put_destination_policy_http_response(
   75     66   
    _response_status: u16,
   76     67   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +123,108 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::put_index_policy::PutIndexPolicyError::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::put_index_policy::PutIndexPolicyError::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::put_index_policy::PutIndexPolicyError::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::put_index_policy::PutIndexPolicyError::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::put_index_policy::PutIndexPolicyError::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::put_index_policy::PutIndexPolicyError::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::put_index_policy::PutIndexPolicyError::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::put_index_policy::PutIndexPolicyError::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::put_index_policy::PutIndexPolicyError::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::put_index_policy::PutIndexPolicyError::unhandled)?;
   88     76   
                let output = output.meta(generic);
   89     77   
                output.build()
   90     78   
            };
   91         -
            if tmp.message.is_none() {
   92         -
                tmp.message = _error_message;
   93         -
            }
   94     79   
            tmp
   95     80   
        }),
   96     81   
        _ => crate::operation::put_index_policy::PutIndexPolicyError::generic(generic),
   97     82   
    })
   98     83   
}
   99     84   
  100     85   
#[allow(clippy::unnecessary_wraps)]
  101     86   
pub fn de_put_index_policy_http_response(
  102     87   
    _response_status: u16,
  103     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +108,96 @@
   20     20   
        "ValidationException" => crate::operation::put_integration::PutIntegrationError::ValidationException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::put_integration::PutIntegrationError::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::put_integration::PutIntegrationError::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::put_integration::PutIntegrationError::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::put_integration::PutIntegrationError::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::put_integration::PutIntegrationError::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::put_integration::PutIntegrationError::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::put_integration::PutIntegrationError::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::put_integration::PutIntegrationError::generic(generic),
   82     70   
    })
   83     71   
}
   84     72   
   85     73   
#[allow(clippy::unnecessary_wraps)]
   86     74   
pub fn de_put_integration_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_put_log_events.rs

@@ -1,1 +143,125 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::put_log_events::PutLogEventsError::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::put_log_events::PutLogEventsError::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::put_log_events::PutLogEventsError::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::put_log_events::PutLogEventsError::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::put_log_events::PutLogEventsError::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::put_log_events::PutLogEventsError::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   
        "UnrecognizedClientException" => crate::operation::put_log_events::PutLogEventsError::UnrecognizedClientException({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::UnrecognizedClientExceptionBuilder::default();
   71     62   
                output =
   72     63   
                    crate::protocol_serde::shape_unrecognized_client_exception::de_unrecognized_client_exception_json_err(_response_body, output)
   73     64   
                        .map_err(crate::operation::put_log_events::PutLogEventsError::unhandled)?;
   74     65   
                let output = output.meta(generic);
   75     66   
                output.build()
   76     67   
            };
   77         -
            if tmp.message.is_none() {
   78         -
                tmp.message = _error_message;
   79         -
            }
   80     68   
            tmp
   81     69   
        }),
   82     70   
        "InvalidSequenceTokenException" => crate::operation::put_log_events::PutLogEventsError::InvalidSequenceTokenException({
   83     71   
            #[allow(unused_mut)]
   84     72   
            let mut tmp = {
   85     73   
                #[allow(unused_mut)]
   86     74   
                let mut output = crate::types::error::builders::InvalidSequenceTokenExceptionBuilder::default();
   87     75   
                output = crate::protocol_serde::shape_invalid_sequence_token_exception::de_invalid_sequence_token_exception_json_err(
   88     76   
                    _response_body,
   89     77   
                    output,
   90     78   
                )
   91     79   
                .map_err(crate::operation::put_log_events::PutLogEventsError::unhandled)?;
   92     80   
                let output = output.meta(generic);
   93     81   
                output.build()
   94     82   
            };
   95         -
            if tmp.message.is_none() {
   96         -
                tmp.message = _error_message;
   97         -
            }
   98     83   
            tmp
   99     84   
        }),
  100     85   
        "DataAlreadyAcceptedException" => crate::operation::put_log_events::PutLogEventsError::DataAlreadyAcceptedException({
  101     86   
            #[allow(unused_mut)]
  102     87   
            let mut tmp = {
  103     88   
                #[allow(unused_mut)]
  104     89   
                let mut output = crate::types::error::builders::DataAlreadyAcceptedExceptionBuilder::default();
  105     90   
                output =
  106     91   
                    crate::protocol_serde::shape_data_already_accepted_exception::de_data_already_accepted_exception_json_err(_response_body, output)
  107     92   
                        .map_err(crate::operation::put_log_events::PutLogEventsError::unhandled)?;
  108     93   
                let output = output.meta(generic);
  109     94   
                output.build()
  110     95   
            };
  111         -
            if tmp.message.is_none() {
  112         -
                tmp.message = _error_message;
  113         -
            }
  114     96   
            tmp
  115     97   
        }),
  116     98   
        _ => crate::operation::put_log_events::PutLogEventsError::generic(generic),
  117     99   
    })
  118    100   
}
  119    101   
  120    102   
#[allow(clippy::unnecessary_wraps)]
  121    103   
pub fn de_put_log_events_http_response(
  122    104   
    _response_status: u16,
  123    105   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

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

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

@@ -3,3 +111,99 @@
   23     23   
        "ResourceNotFoundException" => crate::operation::put_query_definition::PutQueryDefinitionError::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::put_query_definition::PutQueryDefinitionError::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::put_query_definition::PutQueryDefinitionError::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::put_query_definition::PutQueryDefinitionError::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   
        "LimitExceededException" => crate::operation::put_query_definition::PutQueryDefinitionError::LimitExceededException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::put_query_definition::PutQueryDefinitionError::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::put_query_definition::PutQueryDefinitionError::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::put_query_definition::PutQueryDefinitionError::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::put_query_definition::PutQueryDefinitionError::generic(generic),
   85     73   
    })
   86     74   
}
   87     75   
   88     76   
#[allow(clippy::unnecessary_wraps)]
   89     77   
pub fn de_put_query_definition_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_put_resource_policy.rs

@@ -1,1 +94,85 @@
   21     21   
        "InvalidParameterException" => crate::operation::put_resource_policy::PutResourcePolicyError::InvalidParameterException({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::put_resource_policy::PutResourcePolicyError::unhandled)?;
   28     28   
                let output = output.meta(generic);
   29     29   
                output.build()
   30     30   
            };
   31         -
            if tmp.message.is_none() {
   32         -
                tmp.message = _error_message;
   33         -
            }
   34     31   
            tmp
   35     32   
        }),
   36     33   
        "LimitExceededException" => crate::operation::put_resource_policy::PutResourcePolicyError::LimitExceededException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::put_resource_policy::PutResourcePolicyError::unhandled)?;
   43     40   
                let output = output.meta(generic);
   44     41   
                output.build()
   45     42   
            };
   46         -
            if tmp.message.is_none() {
   47         -
                tmp.message = _error_message;
   48         -
            }
   49     43   
            tmp
   50     44   
        }),
   51     45   
        "ServiceUnavailableException" => crate::operation::put_resource_policy::PutResourcePolicyError::ServiceUnavailableException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   56     50   
                output =
   57     51   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   58     52   
                        .map_err(crate::operation::put_resource_policy::PutResourcePolicyError::unhandled)?;
   59     53   
                let output = output.meta(generic);
   60     54   
                output.build()
   61     55   
            };
   62         -
            if tmp.message.is_none() {
   63         -
                tmp.message = _error_message;
   64         -
            }
   65     56   
            tmp
   66     57   
        }),
   67     58   
        _ => crate::operation::put_resource_policy::PutResourcePolicyError::generic(generic),
   68     59   
    })
   69     60   
}
   70     61   
   71     62   
#[allow(clippy::unnecessary_wraps)]
   72     63   
pub fn de_put_resource_policy_http_response(
   73     64   
    _response_status: u16,
   74     65   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +111,99 @@
   23     23   
        "ResourceNotFoundException" => crate::operation::put_retention_policy::PutRetentionPolicyError::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::put_retention_policy::PutRetentionPolicyError::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::put_retention_policy::PutRetentionPolicyError::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::put_retention_policy::PutRetentionPolicyError::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::put_retention_policy::PutRetentionPolicyError::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::put_retention_policy::PutRetentionPolicyError::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::put_retention_policy::PutRetentionPolicyError::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::put_retention_policy::PutRetentionPolicyError::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::put_retention_policy::PutRetentionPolicyError::generic(generic),
   85     73   
    })
   86     74   
}
   87     75   
   88     76   
#[allow(clippy::unnecessary_wraps)]
   89     77   
pub fn de_put_retention_policy_http_response(
   90     78   
    _response_status: u16,
   91     79   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,