AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05 (ignoring whitespace)

Files changed:

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

@@ -3,3 +114,102 @@
   23     23   
        "ThrottlingException" => crate::operation::describe_deliveries::DescribeDeliveriesError::ThrottlingException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::describe_deliveries::DescribeDeliveriesError::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::describe_deliveries::DescribeDeliveriesError::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::describe_deliveries::DescribeDeliveriesError::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::describe_deliveries::DescribeDeliveriesError::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::describe_deliveries::DescribeDeliveriesError::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   
        "ServiceQuotaExceededException" => crate::operation::describe_deliveries::DescribeDeliveriesError::ServiceQuotaExceededException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
   75     66   
                    _response_body,
   76     67   
                    output,
   77     68   
                )
   78     69   
                .map_err(crate::operation::describe_deliveries::DescribeDeliveriesError::unhandled)?;
   79     70   
                let output = output.meta(generic);
   80     71   
                output.build()
   81     72   
            };
   82         -
            if tmp.message.is_none() {
   83         -
                tmp.message = _error_message;
   84         -
            }
   85     73   
            tmp
   86     74   
        }),
   87     75   
        _ => crate::operation::describe_deliveries::DescribeDeliveriesError::generic(generic),
   88     76   
    })
   89     77   
}
   90     78   
   91     79   
#[allow(clippy::unnecessary_wraps)]
   92     80   
pub fn de_describe_deliveries_http_response(
   93     81   
    _response_status: u16,
   94     82   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +117,105 @@
   23     23   
        "ThrottlingException" => crate::operation::describe_delivery_destinations::DescribeDeliveryDestinationsError::ThrottlingException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::describe_delivery_destinations::DescribeDeliveryDestinationsError::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::describe_delivery_destinations::DescribeDeliveryDestinationsError::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::describe_delivery_destinations::DescribeDeliveryDestinationsError::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" => {
   54     48   
            crate::operation::describe_delivery_destinations::DescribeDeliveryDestinationsError::ServiceUnavailableException({
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut tmp = {
   57     51   
                    #[allow(unused_mut)]
   58     52   
                    let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   59     53   
                    output =
   60     54   
                        crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   61     55   
                            .map_err(crate::operation::describe_delivery_destinations::DescribeDeliveryDestinationsError::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   
        "ServiceQuotaExceededException" => {
   72     63   
            crate::operation::describe_delivery_destinations::DescribeDeliveryDestinationsError::ServiceQuotaExceededException({
   73     64   
                #[allow(unused_mut)]
   74     65   
                let mut tmp = {
   75     66   
                    #[allow(unused_mut)]
   76     67   
                    let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
   77     68   
                    output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
   78     69   
                        _response_body,
   79     70   
                        output,
   80     71   
                    )
   81     72   
                    .map_err(crate::operation::describe_delivery_destinations::DescribeDeliveryDestinationsError::unhandled)?;
   82     73   
                    let output = output.meta(generic);
   83     74   
                    output.build()
   84     75   
                };
   85         -
                if tmp.message.is_none() {
   86         -
                    tmp.message = _error_message;
   87         -
                }
   88     76   
                tmp
   89     77   
            })
   90     78   
        }
   91     79   
        _ => crate::operation::describe_delivery_destinations::DescribeDeliveryDestinationsError::generic(generic),
   92     80   
    })
   93     81   
}
   94     82   
   95     83   
#[allow(clippy::unnecessary_wraps)]
   96     84   
pub fn de_describe_delivery_destinations_http_response(
   97     85   
    _response_status: u16,

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

@@ -7,7 +119,107 @@
   27     27   
        "ThrottlingException" => crate::operation::describe_delivery_sources::DescribeDeliverySourcesError::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::describe_delivery_sources::DescribeDeliverySourcesError::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   
        "ValidationException" => crate::operation::describe_delivery_sources::DescribeDeliverySourcesError::ValidationException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::ValidationExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::describe_delivery_sources::DescribeDeliverySourcesError::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   
        "ServiceUnavailableException" => crate::operation::describe_delivery_sources::DescribeDeliverySourcesError::ServiceUnavailableException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   62     56   
                output =
   63     57   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   64     58   
                        .map_err(crate::operation::describe_delivery_sources::DescribeDeliverySourcesError::unhandled)?;
   65     59   
                let output = output.meta(generic);
   66     60   
                output.build()
   67     61   
            };
   68         -
            if tmp.message.is_none() {
   69         -
                tmp.message = _error_message;
   70         -
            }
   71     62   
            tmp
   72     63   
        }),
   73     64   
        "ServiceQuotaExceededException" => {
   74     65   
            crate::operation::describe_delivery_sources::DescribeDeliverySourcesError::ServiceQuotaExceededException({
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut tmp = {
   77     68   
                    #[allow(unused_mut)]
   78     69   
                    let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
   79     70   
                    output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
   80     71   
                        _response_body,
   81     72   
                        output,
   82     73   
                    )
   83     74   
                    .map_err(crate::operation::describe_delivery_sources::DescribeDeliverySourcesError::unhandled)?;
   84     75   
                    let output = output.meta(generic);
   85     76   
                    output.build()
   86     77   
                };
   87         -
                if tmp.message.is_none() {
   88         -
                    tmp.message = _error_message;
   89         -
                }
   90     78   
                tmp
   91     79   
            })
   92     80   
        }
   93     81   
        _ => crate::operation::describe_delivery_sources::DescribeDeliverySourcesError::generic(generic),
   94     82   
    })
   95     83   
}
   96     84   
   97     85   
#[allow(clippy::unnecessary_wraps)]
   98     86   
pub fn de_describe_delivery_sources_http_response(
   99     87   
    _response_status: u16,

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

@@ -3,3 +81,75 @@
   23     23   
        "InvalidParameterException" => crate::operation::describe_destinations::DescribeDestinationsError::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::describe_destinations::DescribeDestinationsError::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   
        "ServiceUnavailableException" => crate::operation::describe_destinations::DescribeDestinationsError::ServiceUnavailableException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   43     40   
                output =
   44     41   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   45     42   
                        .map_err(crate::operation::describe_destinations::DescribeDestinationsError::unhandled)?;
   46     43   
                let output = output.meta(generic);
   47     44   
                output.build()
   48     45   
            };
   49         -
            if tmp.message.is_none() {
   50         -
                tmp.message = _error_message;
   51         -
            }
   52     46   
            tmp
   53     47   
        }),
   54     48   
        _ => crate::operation::describe_destinations::DescribeDestinationsError::generic(generic),
   55     49   
    })
   56     50   
}
   57     51   
   58     52   
#[allow(clippy::unnecessary_wraps)]
   59     53   
pub fn de_describe_destinations_http_response(
   60     54   
    _response_status: u16,
   61     55   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +81,75 @@
   23     23   
        "InvalidParameterException" => crate::operation::describe_export_tasks::DescribeExportTasksError::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::describe_export_tasks::DescribeExportTasksError::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   
        "ServiceUnavailableException" => crate::operation::describe_export_tasks::DescribeExportTasksError::ServiceUnavailableException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   43     40   
                output =
   44     41   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   45     42   
                        .map_err(crate::operation::describe_export_tasks::DescribeExportTasksError::unhandled)?;
   46     43   
                let output = output.meta(generic);
   47     44   
                output.build()
   48     45   
            };
   49         -
            if tmp.message.is_none() {
   50         -
                tmp.message = _error_message;
   51         -
            }
   52     46   
            tmp
   53     47   
        }),
   54     48   
        _ => crate::operation::describe_export_tasks::DescribeExportTasksError::generic(generic),
   55     49   
    })
   56     50   
}
   57     51   
   58     52   
#[allow(clippy::unnecessary_wraps)]
   59     53   
pub fn de_describe_export_tasks_http_response(
   60     54   
    _response_status: u16,
   61     55   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +126,111 @@
   23     23   
        "ResourceNotFoundException" => crate::operation::describe_field_indexes::DescribeFieldIndexesError::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::describe_field_indexes::DescribeFieldIndexesError::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::describe_field_indexes::DescribeFieldIndexesError::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::describe_field_indexes::DescribeFieldIndexesError::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::describe_field_indexes::DescribeFieldIndexesError::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::describe_field_indexes::DescribeFieldIndexesError::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   
        "OperationAbortedException" => crate::operation::describe_field_indexes::DescribeFieldIndexesError::OperationAbortedException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::OperationAbortedExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_operation_aborted_exception::de_operation_aborted_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::describe_field_indexes::DescribeFieldIndexesError::unhandled)?;
   75     66   
                let output = output.meta(generic);
   76     67   
                output.build()
   77     68   
            };
   78         -
            if tmp.message.is_none() {
   79         -
                tmp.message = _error_message;
   80         -
            }
   81     69   
            tmp
   82     70   
        }),
   83     71   
        "ServiceUnavailableException" => crate::operation::describe_field_indexes::DescribeFieldIndexesError::ServiceUnavailableException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   88     76   
                output =
   89     77   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   90     78   
                        .map_err(crate::operation::describe_field_indexes::DescribeFieldIndexesError::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::describe_field_indexes::DescribeFieldIndexesError::generic(generic),
  100     85   
    })
  101     86   
}
  102     87   
  103     88   
#[allow(clippy::unnecessary_wraps)]
  104     89   
pub fn de_describe_field_indexes_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_describe_index_policies.rs

@@ -3,3 +126,111 @@
   23     23   
        "ResourceNotFoundException" => crate::operation::describe_index_policies::DescribeIndexPoliciesError::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::describe_index_policies::DescribeIndexPoliciesError::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::describe_index_policies::DescribeIndexPoliciesError::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::describe_index_policies::DescribeIndexPoliciesError::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::describe_index_policies::DescribeIndexPoliciesError::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::describe_index_policies::DescribeIndexPoliciesError::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   
        "OperationAbortedException" => crate::operation::describe_index_policies::DescribeIndexPoliciesError::OperationAbortedException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::OperationAbortedExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_operation_aborted_exception::de_operation_aborted_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::describe_index_policies::DescribeIndexPoliciesError::unhandled)?;
   75     66   
                let output = output.meta(generic);
   76     67   
                output.build()
   77     68   
            };
   78         -
            if tmp.message.is_none() {
   79         -
                tmp.message = _error_message;
   80         -
            }
   81     69   
            tmp
   82     70   
        }),
   83     71   
        "ServiceUnavailableException" => crate::operation::describe_index_policies::DescribeIndexPoliciesError::ServiceUnavailableException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   88     76   
                output =
   89     77   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   90     78   
                        .map_err(crate::operation::describe_index_policies::DescribeIndexPoliciesError::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::describe_index_policies::DescribeIndexPoliciesError::generic(generic),
  100     85   
    })
  101     86   
}
  102     87   
  103     88   
#[allow(clippy::unnecessary_wraps)]
  104     89   
pub fn de_describe_index_policies_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_describe_log_groups.rs

@@ -1,1 +79,73 @@
   21     21   
        "InvalidParameterException" => crate::operation::describe_log_groups::DescribeLogGroupsError::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::describe_log_groups::DescribeLogGroupsError::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::describe_log_groups::DescribeLogGroupsError::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::describe_log_groups::DescribeLogGroupsError::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::describe_log_groups::DescribeLogGroupsError::generic(generic),
   53     47   
    })
   54     48   
}
   55     49   
   56     50   
#[allow(clippy::unnecessary_wraps)]
   57     51   
pub fn de_describe_log_groups_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_describe_log_streams.rs

@@ -3,3 +96,87 @@
   23     23   
        "ResourceNotFoundException" => crate::operation::describe_log_streams::DescribeLogStreamsError::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::describe_log_streams::DescribeLogStreamsError::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::describe_log_streams::DescribeLogStreamsError::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::describe_log_streams::DescribeLogStreamsError::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::describe_log_streams::DescribeLogStreamsError::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::describe_log_streams::DescribeLogStreamsError::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::describe_log_streams::DescribeLogStreamsError::generic(generic),
   70     61   
    })
   71     62   
}
   72     63   
   73     64   
#[allow(clippy::unnecessary_wraps)]
   74     65   
pub fn de_describe_log_streams_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_describe_metric_filters.rs

@@ -3,3 +96,87 @@
   23     23   
        "ResourceNotFoundException" => crate::operation::describe_metric_filters::DescribeMetricFiltersError::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::describe_metric_filters::DescribeMetricFiltersError::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::describe_metric_filters::DescribeMetricFiltersError::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::describe_metric_filters::DescribeMetricFiltersError::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::describe_metric_filters::DescribeMetricFiltersError::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::describe_metric_filters::DescribeMetricFiltersError::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::describe_metric_filters::DescribeMetricFiltersError::generic(generic),
   70     61   
    })
   71     62   
}
   72     63   
   73     64   
#[allow(clippy::unnecessary_wraps)]
   74     65   
pub fn de_describe_metric_filters_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_describe_queries.rs

@@ -1,1 +93,84 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::describe_queries::DescribeQueriesError::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::describe_queries::DescribeQueriesError::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::describe_queries::DescribeQueriesError::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::describe_queries::DescribeQueriesError::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::describe_queries::DescribeQueriesError::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::describe_queries::DescribeQueriesError::unhandled)?;
   58     52   
                let output = output.meta(generic);
   59     53   
                output.build()
   60     54   
            };
   61         -
            if tmp.message.is_none() {
   62         -
                tmp.message = _error_message;
   63         -
            }
   64     55   
            tmp
   65     56   
        }),
   66     57   
        _ => crate::operation::describe_queries::DescribeQueriesError::generic(generic),
   67     58   
    })
   68     59   
}
   69     60   
   70     61   
#[allow(clippy::unnecessary_wraps)]
   71     62   
pub fn de_describe_queries_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_describe_query_definitions.rs

@@ -7,7 +85,79 @@
   27     27   
        "InvalidParameterException" => crate::operation::describe_query_definitions::DescribeQueryDefinitionsError::InvalidParameterException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::describe_query_definitions::DescribeQueryDefinitionsError::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   
        "ServiceUnavailableException" => crate::operation::describe_query_definitions::DescribeQueryDefinitionsError::ServiceUnavailableException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   47     44   
                output =
   48     45   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   49     46   
                        .map_err(crate::operation::describe_query_definitions::DescribeQueryDefinitionsError::unhandled)?;
   50     47   
                let output = output.meta(generic);
   51     48   
                output.build()
   52     49   
            };
   53         -
            if tmp.message.is_none() {
   54         -
                tmp.message = _error_message;
   55         -
            }
   56     50   
            tmp
   57     51   
        }),
   58     52   
        _ => crate::operation::describe_query_definitions::DescribeQueryDefinitionsError::generic(generic),
   59     53   
    })
   60     54   
}
   61     55   
   62     56   
#[allow(clippy::unnecessary_wraps)]
   63     57   
pub fn de_describe_query_definitions_http_response(
   64     58   
    _response_status: u16,
   65     59   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +85,79 @@
   27     27   
        "InvalidParameterException" => crate::operation::describe_resource_policies::DescribeResourcePoliciesError::InvalidParameterException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::InvalidParameterExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::describe_resource_policies::DescribeResourcePoliciesError::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   
        "ServiceUnavailableException" => crate::operation::describe_resource_policies::DescribeResourcePoliciesError::ServiceUnavailableException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   47     44   
                output =
   48     45   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   49     46   
                        .map_err(crate::operation::describe_resource_policies::DescribeResourcePoliciesError::unhandled)?;
   50     47   
                let output = output.meta(generic);
   51     48   
                output.build()
   52     49   
            };
   53         -
            if tmp.message.is_none() {
   54         -
                tmp.message = _error_message;
   55         -
            }
   56     50   
            tmp
   57     51   
        }),
   58     52   
        _ => crate::operation::describe_resource_policies::DescribeResourcePoliciesError::generic(generic),
   59     53   
    })
   60     54   
}
   61     55   
   62     56   
#[allow(clippy::unnecessary_wraps)]
   63     57   
pub fn de_describe_resource_policies_http_response(
   64     58   
    _response_status: u16,
   65     59   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -5,5 +103,94 @@
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   29     29   
                    output =
   30     30   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   31     31   
                            .map_err(crate::operation::describe_subscription_filters::DescribeSubscriptionFiltersError::unhandled)?;
   32     32   
                    let output = output.meta(generic);
   33     33   
                    output.build()
   34     34   
                };
   35         -
                if tmp.message.is_none() {
   36         -
                    tmp.message = _error_message;
   37         -
                }
   38     35   
                tmp
   39     36   
            })
   40     37   
        }
   41     38   
        "InvalidParameterException" => {
   42     39   
            crate::operation::describe_subscription_filters::DescribeSubscriptionFiltersError::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 =
   48     45   
                        crate::protocol_serde::shape_invalid_parameter_exception::de_invalid_parameter_exception_json_err(_response_body, output)
   49     46   
                            .map_err(crate::operation::describe_subscription_filters::DescribeSubscriptionFiltersError::unhandled)?;
   50     47   
                    let output = output.meta(generic);
   51     48   
                    output.build()
   52     49   
                };
   53         -
                if tmp.message.is_none() {
   54         -
                    tmp.message = _error_message;
   55         -
                }
   56     50   
                tmp
   57     51   
            })
   58     52   
        }
   59     53   
        "ServiceUnavailableException" => {
   60     54   
            crate::operation::describe_subscription_filters::DescribeSubscriptionFiltersError::ServiceUnavailableException({
   61     55   
                #[allow(unused_mut)]
   62     56   
                let mut tmp = {
   63     57   
                    #[allow(unused_mut)]
   64     58   
                    let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   65     59   
                    output =
   66     60   
                        crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   67     61   
                            .map_err(crate::operation::describe_subscription_filters::DescribeSubscriptionFiltersError::unhandled)?;
   68     62   
                    let output = output.meta(generic);
   69     63   
                    output.build()
   70     64   
                };
   71         -
                if tmp.message.is_none() {
   72         -
                    tmp.message = _error_message;
   73         -
                }
   74     65   
                tmp
   75     66   
            })
   76     67   
        }
   77     68   
        _ => crate::operation::describe_subscription_filters::DescribeSubscriptionFiltersError::generic(generic),
   78     69   
    })
   79     70   
}
   80     71   
   81     72   
#[allow(clippy::unnecessary_wraps)]
   82     73   
pub fn de_describe_subscription_filters_http_response(
   83     74   
    _response_status: u16,

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

@@ -3,3 +111,99 @@
   23     23   
        "ResourceNotFoundException" => crate::operation::disassociate_kms_key::DisassociateKmsKeyError::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::disassociate_kms_key::DisassociateKmsKeyError::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::disassociate_kms_key::DisassociateKmsKeyError::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::disassociate_kms_key::DisassociateKmsKeyError::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::disassociate_kms_key::DisassociateKmsKeyError::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::disassociate_kms_key::DisassociateKmsKeyError::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::disassociate_kms_key::DisassociateKmsKeyError::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::disassociate_kms_key::DisassociateKmsKeyError::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::disassociate_kms_key::DisassociateKmsKeyError::generic(generic),
   85     73   
    })
   86     74   
}
   87     75   
   88     76   
#[allow(clippy::unnecessary_wraps)]
   89     77   
pub fn de_disassociate_kms_key_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_filter_log_events.rs

@@ -1,1 +93,84 @@
   20     20   
        "ResourceNotFoundException" => crate::operation::filter_log_events::FilterLogEventsError::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::filter_log_events::FilterLogEventsError::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::filter_log_events::FilterLogEventsError::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::filter_log_events::FilterLogEventsError::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::filter_log_events::FilterLogEventsError::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::filter_log_events::FilterLogEventsError::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::filter_log_events::FilterLogEventsError::generic(generic),
   67     58   
    })
   68     59   
}
   69     60   
   70     61   
#[allow(clippy::unnecessary_wraps)]
   71     62   
pub fn de_filter_log_events_http_response(
   72     63   
    _response_status: u16,
   73     64   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,