AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_code_signing_config.rs

@@ -6,6 +98,89 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::get_code_signing_config::GetCodeSigningConfigError::unhandled)?;
   33     33   
                let output = output.meta(generic);
   34     34   
                output.build()
   35     35   
            };
   36         -
            if tmp.message.is_none() {
   37         -
                tmp.message = _error_message;
   38         -
            }
   39     36   
            tmp
   40     37   
        }),
   41     38   
        "ResourceNotFoundException" => crate::operation::get_code_signing_config::GetCodeSigningConfigError::ResourceNotFoundException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::get_code_signing_config::GetCodeSigningConfigError::unhandled)?;
   48     45   
                let output = output.meta(generic);
   49     46   
                output.build()
   50     47   
            };
   51         -
            if tmp.message.is_none() {
   52         -
                tmp.message = _error_message;
   53         -
            }
   54     48   
            tmp
   55     49   
        }),
   56     50   
        "ServiceException" => crate::operation::get_code_signing_config::GetCodeSigningConfigError::ServiceException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::get_code_signing_config::GetCodeSigningConfigError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        _ => crate::operation::get_code_signing_config::GetCodeSigningConfigError::generic(generic),
   72     63   
    })
   73     64   
}
   74     65   
   75     66   
#[allow(clippy::unnecessary_wraps)]
   76     67   
pub fn de_get_code_signing_config_http_response(
   77     68   
    _response_status: u16,
   78     69   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_event_source_mapping.rs

@@ -6,6 +120,108 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::get_event_source_mapping::GetEventSourceMappingError::unhandled)?;
   33     33   
                let output = output.meta(generic);
   34     34   
                output.build()
   35     35   
            };
   36         -
            if tmp.message.is_none() {
   37         -
                tmp.message = _error_message;
   38         -
            }
   39     36   
            tmp
   40     37   
        }),
   41     38   
        "ResourceNotFoundException" => crate::operation::get_event_source_mapping::GetEventSourceMappingError::ResourceNotFoundException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::get_event_source_mapping::GetEventSourceMappingError::unhandled)?;
   48     45   
                let output = output.meta(generic);
   49     46   
                output.build()
   50     47   
            };
   51         -
            if tmp.message.is_none() {
   52         -
                tmp.message = _error_message;
   53         -
            }
   54     48   
            tmp
   55     49   
        }),
   56     50   
        "ServiceException" => crate::operation::get_event_source_mapping::GetEventSourceMappingError::ServiceException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::get_event_source_mapping::GetEventSourceMappingError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "TooManyRequestsException" => crate::operation::get_event_source_mapping::GetEventSourceMappingError::TooManyRequestsException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::get_event_source_mapping::GetEventSourceMappingError::unhandled)?;
   78     69   
                output = output.set_retry_after_seconds(
   79     70   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   80     71   
                        crate::operation::get_event_source_mapping::GetEventSourceMappingError::unhandled(
   81     72   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   82     73   
                        )
   83     74   
                    })?,
   84     75   
                );
   85     76   
                let output = output.meta(generic);
   86     77   
                output.build()
   87     78   
            };
   88         -
            if tmp.message.is_none() {
   89         -
                tmp.message = _error_message;
   90         -
            }
   91     79   
            tmp
   92     80   
        }),
   93     81   
        _ => crate::operation::get_event_source_mapping::GetEventSourceMappingError::generic(generic),
   94     82   
    })
   95     83   
}
   96     84   
   97     85   
#[allow(clippy::unnecessary_wraps)]
   98     86   
pub fn de_get_event_source_mapping_http_response(
   99     87   
    _response_status: u16,
  100     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_function.rs

@@ -3,3 +115,103 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::get_function::GetFunctionError::unhandled)?;
   30     30   
                let output = output.meta(generic);
   31     31   
                output.build()
   32     32   
            };
   33         -
            if tmp.message.is_none() {
   34         -
                tmp.message = _error_message;
   35         -
            }
   36     33   
            tmp
   37     34   
        }),
   38     35   
        "ResourceNotFoundException" => crate::operation::get_function::GetFunctionError::ResourceNotFoundException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::get_function::GetFunctionError::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   
        "ServiceException" => crate::operation::get_function::GetFunctionError::ServiceException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::get_function::GetFunctionError::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   
        "TooManyRequestsException" => crate::operation::get_function::GetFunctionError::TooManyRequestsException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::get_function::GetFunctionError::unhandled)?;
   75     66   
                output = output.set_retry_after_seconds(
   76     67   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   77     68   
                        crate::operation::get_function::GetFunctionError::unhandled("Failed to parse retryAfterSeconds from header `Retry-After")
   78     69   
                    })?,
   79     70   
                );
   80     71   
                let output = output.meta(generic);
   81     72   
                output.build()
   82     73   
            };
   83         -
            if tmp.message.is_none() {
   84         -
                tmp.message = _error_message;
   85         -
            }
   86     74   
            tmp
   87     75   
        }),
   88     76   
        _ => crate::operation::get_function::GetFunctionError::generic(generic),
   89     77   
    })
   90     78   
}
   91     79   
   92     80   
#[allow(clippy::unnecessary_wraps)]
   93     81   
pub fn de_get_function_http_response(
   94     82   
    _response_status: u16,
   95     83   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_function_code_signing_config.rs

@@ -7,7 +127,115 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::get_function_code_signing_config::GetFunctionCodeSigningConfigError::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   
        }
   43     40   
        "ResourceNotFoundException" => {
   44     41   
            crate::operation::get_function_code_signing_config::GetFunctionCodeSigningConfigError::ResourceNotFoundException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   49     46   
                    output =
   50     47   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   51     48   
                            .map_err(crate::operation::get_function_code_signing_config::GetFunctionCodeSigningConfigError::unhandled)?;
   52     49   
                    let output = output.meta(generic);
   53     50   
                    output.build()
   54     51   
                };
   55         -
                if tmp.message.is_none() {
   56         -
                    tmp.message = _error_message;
   57         -
                }
   58     52   
                tmp
   59     53   
            })
   60     54   
        }
   61     55   
        "ServiceException" => crate::operation::get_function_code_signing_config::GetFunctionCodeSigningConfigError::ServiceException({
   62     56   
            #[allow(unused_mut)]
   63     57   
            let mut tmp = {
   64     58   
                #[allow(unused_mut)]
   65     59   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   66     60   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   67     61   
                    .map_err(crate::operation::get_function_code_signing_config::GetFunctionCodeSigningConfigError::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   
        "TooManyRequestsException" => {
   77     68   
            crate::operation::get_function_code_signing_config::GetFunctionCodeSigningConfigError::TooManyRequestsException({
   78     69   
                #[allow(unused_mut)]
   79     70   
                let mut tmp = {
   80     71   
                    #[allow(unused_mut)]
   81     72   
                    let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   82     73   
                    output =
   83     74   
                        crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   84     75   
                            .map_err(crate::operation::get_function_code_signing_config::GetFunctionCodeSigningConfigError::unhandled)?;
   85     76   
                    output = output.set_retry_after_seconds(
   86     77   
                        crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   87     78   
                            crate::operation::get_function_code_signing_config::GetFunctionCodeSigningConfigError::unhandled(
   88     79   
                                "Failed to parse retryAfterSeconds from header `Retry-After",
   89     80   
                            )
   90     81   
                        })?,
   91     82   
                    );
   92     83   
                    let output = output.meta(generic);
   93     84   
                    output.build()
   94     85   
                };
   95         -
                if tmp.message.is_none() {
   96         -
                    tmp.message = _error_message;
   97         -
                }
   98     86   
                tmp
   99     87   
            })
  100     88   
        }
  101     89   
        _ => crate::operation::get_function_code_signing_config::GetFunctionCodeSigningConfigError::generic(generic),
  102     90   
    })
  103     91   
}
  104     92   
  105     93   
#[allow(clippy::unnecessary_wraps)]
  106     94   
pub fn de_get_function_code_signing_config_http_response(
  107     95   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_function_concurrency.rs

@@ -11,11 +126,114 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::get_function_concurrency::GetFunctionConcurrencyError::unhandled)?;
   38     38   
                    let output = output.meta(generic);
   39     39   
                    output.build()
   40     40   
                };
   41         -
                if tmp.message.is_none() {
   42         -
                    tmp.message = _error_message;
   43         -
                }
   44     41   
                tmp
   45     42   
            })
   46     43   
        }
   47     44   
        "ResourceNotFoundException" => crate::operation::get_function_concurrency::GetFunctionConcurrencyError::ResourceNotFoundException({
   48     45   
            #[allow(unused_mut)]
   49     46   
            let mut tmp = {
   50     47   
                #[allow(unused_mut)]
   51     48   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   52     49   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   53     50   
                    .map_err(crate::operation::get_function_concurrency::GetFunctionConcurrencyError::unhandled)?;
   54     51   
                let output = output.meta(generic);
   55     52   
                output.build()
   56     53   
            };
   57         -
            if tmp.message.is_none() {
   58         -
                tmp.message = _error_message;
   59         -
            }
   60     54   
            tmp
   61     55   
        }),
   62     56   
        "ServiceException" => crate::operation::get_function_concurrency::GetFunctionConcurrencyError::ServiceException({
   63     57   
            #[allow(unused_mut)]
   64     58   
            let mut tmp = {
   65     59   
                #[allow(unused_mut)]
   66     60   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   67     61   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   68     62   
                    .map_err(crate::operation::get_function_concurrency::GetFunctionConcurrencyError::unhandled)?;
   69     63   
                let output = output.meta(generic);
   70     64   
                output.build()
   71     65   
            };
   72         -
            if tmp.message.is_none() {
   73         -
                tmp.message = _error_message;
   74         -
            }
   75     66   
            tmp
   76     67   
        }),
   77     68   
        "TooManyRequestsException" => crate::operation::get_function_concurrency::GetFunctionConcurrencyError::TooManyRequestsException({
   78     69   
            #[allow(unused_mut)]
   79     70   
            let mut tmp = {
   80     71   
                #[allow(unused_mut)]
   81     72   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   82     73   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   83     74   
                    .map_err(crate::operation::get_function_concurrency::GetFunctionConcurrencyError::unhandled)?;
   84     75   
                output = output.set_retry_after_seconds(
   85     76   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   86     77   
                        crate::operation::get_function_concurrency::GetFunctionConcurrencyError::unhandled(
   87     78   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   88     79   
                        )
   89     80   
                    })?,
   90     81   
                );
   91     82   
                let output = output.meta(generic);
   92     83   
                output.build()
   93     84   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     85   
            tmp
   98     86   
        }),
   99     87   
        _ => crate::operation::get_function_concurrency::GetFunctionConcurrencyError::generic(generic),
  100     88   
    })
  101     89   
}
  102     90   
  103     91   
#[allow(clippy::unnecessary_wraps)]
  104     92   
pub fn de_get_function_concurrency_http_response(
  105     93   
    _response_status: u16,
  106     94   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_function_configuration.rs

@@ -11,11 +126,114 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::get_function_configuration::GetFunctionConfigurationError::unhandled)?;
   38     38   
                    let output = output.meta(generic);
   39     39   
                    output.build()
   40     40   
                };
   41         -
                if tmp.message.is_none() {
   42         -
                    tmp.message = _error_message;
   43         -
                }
   44     41   
                tmp
   45     42   
            })
   46     43   
        }
   47     44   
        "ResourceNotFoundException" => crate::operation::get_function_configuration::GetFunctionConfigurationError::ResourceNotFoundException({
   48     45   
            #[allow(unused_mut)]
   49     46   
            let mut tmp = {
   50     47   
                #[allow(unused_mut)]
   51     48   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   52     49   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   53     50   
                    .map_err(crate::operation::get_function_configuration::GetFunctionConfigurationError::unhandled)?;
   54     51   
                let output = output.meta(generic);
   55     52   
                output.build()
   56     53   
            };
   57         -
            if tmp.message.is_none() {
   58         -
                tmp.message = _error_message;
   59         -
            }
   60     54   
            tmp
   61     55   
        }),
   62     56   
        "ServiceException" => crate::operation::get_function_configuration::GetFunctionConfigurationError::ServiceException({
   63     57   
            #[allow(unused_mut)]
   64     58   
            let mut tmp = {
   65     59   
                #[allow(unused_mut)]
   66     60   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   67     61   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   68     62   
                    .map_err(crate::operation::get_function_configuration::GetFunctionConfigurationError::unhandled)?;
   69     63   
                let output = output.meta(generic);
   70     64   
                output.build()
   71     65   
            };
   72         -
            if tmp.message.is_none() {
   73         -
                tmp.message = _error_message;
   74         -
            }
   75     66   
            tmp
   76     67   
        }),
   77     68   
        "TooManyRequestsException" => crate::operation::get_function_configuration::GetFunctionConfigurationError::TooManyRequestsException({
   78     69   
            #[allow(unused_mut)]
   79     70   
            let mut tmp = {
   80     71   
                #[allow(unused_mut)]
   81     72   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   82     73   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   83     74   
                    .map_err(crate::operation::get_function_configuration::GetFunctionConfigurationError::unhandled)?;
   84     75   
                output = output.set_retry_after_seconds(
   85     76   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   86     77   
                        crate::operation::get_function_configuration::GetFunctionConfigurationError::unhandled(
   87     78   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   88     79   
                        )
   89     80   
                    })?,
   90     81   
                );
   91     82   
                let output = output.meta(generic);
   92     83   
                output.build()
   93     84   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     85   
            tmp
   98     86   
        }),
   99     87   
        _ => crate::operation::get_function_configuration::GetFunctionConfigurationError::generic(generic),
  100     88   
    })
  101     89   
}
  102     90   
  103     91   
#[allow(clippy::unnecessary_wraps)]
  104     92   
pub fn de_get_function_configuration_http_response(
  105     93   
    _response_status: u16,
  106     94   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_function_event_invoke_config.rs

@@ -7,7 +127,115 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::get_function_event_invoke_config::GetFunctionEventInvokeConfigError::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   
        }
   43     40   
        "ResourceNotFoundException" => {
   44     41   
            crate::operation::get_function_event_invoke_config::GetFunctionEventInvokeConfigError::ResourceNotFoundException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   49     46   
                    output =
   50     47   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   51     48   
                            .map_err(crate::operation::get_function_event_invoke_config::GetFunctionEventInvokeConfigError::unhandled)?;
   52     49   
                    let output = output.meta(generic);
   53     50   
                    output.build()
   54     51   
                };
   55         -
                if tmp.message.is_none() {
   56         -
                    tmp.message = _error_message;
   57         -
                }
   58     52   
                tmp
   59     53   
            })
   60     54   
        }
   61     55   
        "ServiceException" => crate::operation::get_function_event_invoke_config::GetFunctionEventInvokeConfigError::ServiceException({
   62     56   
            #[allow(unused_mut)]
   63     57   
            let mut tmp = {
   64     58   
                #[allow(unused_mut)]
   65     59   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   66     60   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   67     61   
                    .map_err(crate::operation::get_function_event_invoke_config::GetFunctionEventInvokeConfigError::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   
        "TooManyRequestsException" => {
   77     68   
            crate::operation::get_function_event_invoke_config::GetFunctionEventInvokeConfigError::TooManyRequestsException({
   78     69   
                #[allow(unused_mut)]
   79     70   
                let mut tmp = {
   80     71   
                    #[allow(unused_mut)]
   81     72   
                    let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   82     73   
                    output =
   83     74   
                        crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   84     75   
                            .map_err(crate::operation::get_function_event_invoke_config::GetFunctionEventInvokeConfigError::unhandled)?;
   85     76   
                    output = output.set_retry_after_seconds(
   86     77   
                        crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   87     78   
                            crate::operation::get_function_event_invoke_config::GetFunctionEventInvokeConfigError::unhandled(
   88     79   
                                "Failed to parse retryAfterSeconds from header `Retry-After",
   89     80   
                            )
   90     81   
                        })?,
   91     82   
                    );
   92     83   
                    let output = output.meta(generic);
   93     84   
                    output.build()
   94     85   
                };
   95         -
                if tmp.message.is_none() {
   96         -
                    tmp.message = _error_message;
   97         -
                }
   98     86   
                tmp
   99     87   
            })
  100     88   
        }
  101     89   
        _ => crate::operation::get_function_event_invoke_config::GetFunctionEventInvokeConfigError::generic(generic),
  102     90   
    })
  103     91   
}
  104     92   
  105     93   
#[allow(clippy::unnecessary_wraps)]
  106     94   
pub fn de_get_function_event_invoke_config_http_response(
  107     95   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_function_url_config.rs

@@ -6,6 +120,108 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::get_function_url_config::GetFunctionUrlConfigError::unhandled)?;
   33     33   
                let output = output.meta(generic);
   34     34   
                output.build()
   35     35   
            };
   36         -
            if tmp.message.is_none() {
   37         -
                tmp.message = _error_message;
   38         -
            }
   39     36   
            tmp
   40     37   
        }),
   41     38   
        "ResourceNotFoundException" => crate::operation::get_function_url_config::GetFunctionUrlConfigError::ResourceNotFoundException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::get_function_url_config::GetFunctionUrlConfigError::unhandled)?;
   48     45   
                let output = output.meta(generic);
   49     46   
                output.build()
   50     47   
            };
   51         -
            if tmp.message.is_none() {
   52         -
                tmp.message = _error_message;
   53         -
            }
   54     48   
            tmp
   55     49   
        }),
   56     50   
        "ServiceException" => crate::operation::get_function_url_config::GetFunctionUrlConfigError::ServiceException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::get_function_url_config::GetFunctionUrlConfigError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "TooManyRequestsException" => crate::operation::get_function_url_config::GetFunctionUrlConfigError::TooManyRequestsException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::get_function_url_config::GetFunctionUrlConfigError::unhandled)?;
   78     69   
                output = output.set_retry_after_seconds(
   79     70   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   80     71   
                        crate::operation::get_function_url_config::GetFunctionUrlConfigError::unhandled(
   81     72   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   82     73   
                        )
   83     74   
                    })?,
   84     75   
                );
   85     76   
                let output = output.meta(generic);
   86     77   
                output.build()
   87     78   
            };
   88         -
            if tmp.message.is_none() {
   89         -
                tmp.message = _error_message;
   90         -
            }
   91     79   
            tmp
   92     80   
        }),
   93     81   
        _ => crate::operation::get_function_url_config::GetFunctionUrlConfigError::generic(generic),
   94     82   
    })
   95     83   
}
   96     84   
   97     85   
#[allow(clippy::unnecessary_wraps)]
   98     86   
pub fn de_get_function_url_config_http_response(
   99     87   
    _response_status: u16,
  100     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_layer_version.rs

@@ -3,3 +117,105 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::get_layer_version::GetLayerVersionError::unhandled)?;
   30     30   
                let output = output.meta(generic);
   31     31   
                output.build()
   32     32   
            };
   33         -
            if tmp.message.is_none() {
   34         -
                tmp.message = _error_message;
   35         -
            }
   36     33   
            tmp
   37     34   
        }),
   38     35   
        "ResourceNotFoundException" => crate::operation::get_layer_version::GetLayerVersionError::ResourceNotFoundException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::get_layer_version::GetLayerVersionError::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   
        "ServiceException" => crate::operation::get_layer_version::GetLayerVersionError::ServiceException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::get_layer_version::GetLayerVersionError::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   
        "TooManyRequestsException" => crate::operation::get_layer_version::GetLayerVersionError::TooManyRequestsException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::get_layer_version::GetLayerVersionError::unhandled)?;
   75     66   
                output = output.set_retry_after_seconds(
   76     67   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   77     68   
                        crate::operation::get_layer_version::GetLayerVersionError::unhandled(
   78     69   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   79     70   
                        )
   80     71   
                    })?,
   81     72   
                );
   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   
        _ => crate::operation::get_layer_version::GetLayerVersionError::generic(generic),
   91     79   
    })
   92     80   
}
   93     81   
   94     82   
#[allow(clippy::unnecessary_wraps)]
   95     83   
pub fn de_get_layer_version_http_response(
   96     84   
    _response_status: u16,
   97     85   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_layer_version_by_arn.rs

@@ -6,6 +120,108 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::get_layer_version_by_arn::GetLayerVersionByArnError::unhandled)?;
   33     33   
                let output = output.meta(generic);
   34     34   
                output.build()
   35     35   
            };
   36         -
            if tmp.message.is_none() {
   37         -
                tmp.message = _error_message;
   38         -
            }
   39     36   
            tmp
   40     37   
        }),
   41     38   
        "ResourceNotFoundException" => crate::operation::get_layer_version_by_arn::GetLayerVersionByArnError::ResourceNotFoundException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::get_layer_version_by_arn::GetLayerVersionByArnError::unhandled)?;
   48     45   
                let output = output.meta(generic);
   49     46   
                output.build()
   50     47   
            };
   51         -
            if tmp.message.is_none() {
   52         -
                tmp.message = _error_message;
   53         -
            }
   54     48   
            tmp
   55     49   
        }),
   56     50   
        "ServiceException" => crate::operation::get_layer_version_by_arn::GetLayerVersionByArnError::ServiceException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::get_layer_version_by_arn::GetLayerVersionByArnError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "TooManyRequestsException" => crate::operation::get_layer_version_by_arn::GetLayerVersionByArnError::TooManyRequestsException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::get_layer_version_by_arn::GetLayerVersionByArnError::unhandled)?;
   78     69   
                output = output.set_retry_after_seconds(
   79     70   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   80     71   
                        crate::operation::get_layer_version_by_arn::GetLayerVersionByArnError::unhandled(
   81     72   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   82     73   
                        )
   83     74   
                    })?,
   84     75   
                );
   85     76   
                let output = output.meta(generic);
   86     77   
                output.build()
   87     78   
            };
   88         -
            if tmp.message.is_none() {
   89         -
                tmp.message = _error_message;
   90         -
            }
   91     79   
            tmp
   92     80   
        }),
   93     81   
        _ => crate::operation::get_layer_version_by_arn::GetLayerVersionByArnError::generic(generic),
   94     82   
    })
   95     83   
}
   96     84   
   97     85   
#[allow(clippy::unnecessary_wraps)]
   98     86   
pub fn de_get_layer_version_by_arn_http_response(
   99     87   
    _response_status: u16,
  100     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_layer_version_policy.rs

@@ -6,6 +120,108 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::get_layer_version_policy::GetLayerVersionPolicyError::unhandled)?;
   33     33   
                let output = output.meta(generic);
   34     34   
                output.build()
   35     35   
            };
   36         -
            if tmp.message.is_none() {
   37         -
                tmp.message = _error_message;
   38         -
            }
   39     36   
            tmp
   40     37   
        }),
   41     38   
        "ResourceNotFoundException" => crate::operation::get_layer_version_policy::GetLayerVersionPolicyError::ResourceNotFoundException({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::get_layer_version_policy::GetLayerVersionPolicyError::unhandled)?;
   48     45   
                let output = output.meta(generic);
   49     46   
                output.build()
   50     47   
            };
   51         -
            if tmp.message.is_none() {
   52         -
                tmp.message = _error_message;
   53         -
            }
   54     48   
            tmp
   55     49   
        }),
   56     50   
        "ServiceException" => crate::operation::get_layer_version_policy::GetLayerVersionPolicyError::ServiceException({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::get_layer_version_policy::GetLayerVersionPolicyError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "TooManyRequestsException" => crate::operation::get_layer_version_policy::GetLayerVersionPolicyError::TooManyRequestsException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::get_layer_version_policy::GetLayerVersionPolicyError::unhandled)?;
   78     69   
                output = output.set_retry_after_seconds(
   79     70   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   80     71   
                        crate::operation::get_layer_version_policy::GetLayerVersionPolicyError::unhandled(
   81     72   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   82     73   
                        )
   83     74   
                    })?,
   84     75   
                );
   85     76   
                let output = output.meta(generic);
   86     77   
                output.build()
   87     78   
            };
   88         -
            if tmp.message.is_none() {
   89         -
                tmp.message = _error_message;
   90         -
            }
   91     79   
            tmp
   92     80   
        }),
   93     81   
        _ => crate::operation::get_layer_version_policy::GetLayerVersionPolicyError::generic(generic),
   94     82   
    })
   95     83   
}
   96     84   
   97     85   
#[allow(clippy::unnecessary_wraps)]
   98     86   
pub fn de_get_layer_version_policy_http_response(
   99     87   
    _response_status: u16,
  100     88   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_policy.rs

@@ -3,3 +115,103 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::get_policy::GetPolicyError::unhandled)?;
   30     30   
                let output = output.meta(generic);
   31     31   
                output.build()
   32     32   
            };
   33         -
            if tmp.message.is_none() {
   34         -
                tmp.message = _error_message;
   35         -
            }
   36     33   
            tmp
   37     34   
        }),
   38     35   
        "ResourceNotFoundException" => crate::operation::get_policy::GetPolicyError::ResourceNotFoundException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::get_policy::GetPolicyError::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   
        "ServiceException" => crate::operation::get_policy::GetPolicyError::ServiceException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::get_policy::GetPolicyError::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   
        "TooManyRequestsException" => crate::operation::get_policy::GetPolicyError::TooManyRequestsException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::get_policy::GetPolicyError::unhandled)?;
   75     66   
                output = output.set_retry_after_seconds(
   76     67   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   77     68   
                        crate::operation::get_policy::GetPolicyError::unhandled("Failed to parse retryAfterSeconds from header `Retry-After")
   78     69   
                    })?,
   79     70   
                );
   80     71   
                let output = output.meta(generic);
   81     72   
                output.build()
   82     73   
            };
   83         -
            if tmp.message.is_none() {
   84         -
                tmp.message = _error_message;
   85         -
            }
   86     74   
            tmp
   87     75   
        }),
   88     76   
        _ => crate::operation::get_policy::GetPolicyError::generic(generic),
   89     77   
    })
   90     78   
}
   91     79   
   92     80   
#[allow(clippy::unnecessary_wraps)]
   93     81   
pub fn de_get_policy_http_response(
   94     82   
    _response_status: u16,
   95     83   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_provisioned_concurrency_config.rs

@@ -7,7 +145,130 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::get_provisioned_concurrency_config::GetProvisionedConcurrencyConfigError::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   
        }
   43     40   
        "ProvisionedConcurrencyConfigNotFoundException" => {
   44     41   
            crate::operation::get_provisioned_concurrency_config::GetProvisionedConcurrencyConfigError::ProvisionedConcurrencyConfigNotFoundException(
   45     42   
                {
   46     43   
                    #[allow(unused_mut)]
   47     44   
                    let mut tmp = {
   48     45   
                        #[allow(unused_mut)]
   49     46   
                        let mut output = crate::types::error::builders::ProvisionedConcurrencyConfigNotFoundExceptionBuilder::default();
   50     47   
                        output = crate::protocol_serde::shape_provisioned_concurrency_config_not_found_exception::de_provisioned_concurrency_config_not_found_exception_json_err(_response_body, output).map_err(crate::operation::get_provisioned_concurrency_config::GetProvisionedConcurrencyConfigError::unhandled)?;
   51     48   
                        let output = output.meta(generic);
   52     49   
                        output.build()
   53     50   
                    };
   54         -
                    if tmp.message.is_none() {
   55         -
                        tmp.message = _error_message;
   56         -
                    }
   57     51   
                    tmp
   58     52   
                },
   59     53   
            )
   60     54   
        }
   61     55   
        "ResourceNotFoundException" => {
   62     56   
            crate::operation::get_provisioned_concurrency_config::GetProvisionedConcurrencyConfigError::ResourceNotFoundException({
   63     57   
                #[allow(unused_mut)]
   64     58   
                let mut tmp = {
   65     59   
                    #[allow(unused_mut)]
   66     60   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   67     61   
                    output =
   68     62   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   69     63   
                            .map_err(crate::operation::get_provisioned_concurrency_config::GetProvisionedConcurrencyConfigError::unhandled)?;
   70     64   
                    let output = output.meta(generic);
   71     65   
                    output.build()
   72     66   
                };
   73         -
                if tmp.message.is_none() {
   74         -
                    tmp.message = _error_message;
   75         -
                }
   76     67   
                tmp
   77     68   
            })
   78     69   
        }
   79     70   
        "ServiceException" => crate::operation::get_provisioned_concurrency_config::GetProvisionedConcurrencyConfigError::ServiceException({
   80     71   
            #[allow(unused_mut)]
   81     72   
            let mut tmp = {
   82     73   
                #[allow(unused_mut)]
   83     74   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   84     75   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   85     76   
                    .map_err(crate::operation::get_provisioned_concurrency_config::GetProvisionedConcurrencyConfigError::unhandled)?;
   86     77   
                let output = output.meta(generic);
   87     78   
                output.build()
   88     79   
            };
   89         -
            if tmp.message.is_none() {
   90         -
                tmp.message = _error_message;
   91         -
            }
   92     80   
            tmp
   93     81   
        }),
   94     82   
        "TooManyRequestsException" => {
   95     83   
            crate::operation::get_provisioned_concurrency_config::GetProvisionedConcurrencyConfigError::TooManyRequestsException({
   96     84   
                #[allow(unused_mut)]
   97     85   
                let mut tmp = {
   98     86   
                    #[allow(unused_mut)]
   99     87   
                    let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
  100     88   
                    output =
  101     89   
                        crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
  102     90   
                            .map_err(crate::operation::get_provisioned_concurrency_config::GetProvisionedConcurrencyConfigError::unhandled)?;
  103     91   
                    output = output.set_retry_after_seconds(
  104     92   
                        crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
  105     93   
                            crate::operation::get_provisioned_concurrency_config::GetProvisionedConcurrencyConfigError::unhandled(
  106     94   
                                "Failed to parse retryAfterSeconds from header `Retry-After",
  107     95   
                            )
  108     96   
                        })?,
  109     97   
                    );
  110     98   
                    let output = output.meta(generic);
  111     99   
                    output.build()
  112    100   
                };
  113         -
                if tmp.message.is_none() {
  114         -
                    tmp.message = _error_message;
  115         -
                }
  116    101   
                tmp
  117    102   
            })
  118    103   
        }
  119    104   
        _ => crate::operation::get_provisioned_concurrency_config::GetProvisionedConcurrencyConfigError::generic(generic),
  120    105   
    })
  121    106   
}
  122    107   
  123    108   
#[allow(clippy::unnecessary_wraps)]
  124    109   
pub fn de_get_provisioned_concurrency_config_http_response(
  125    110   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_get_runtime_management_config.rs

@@ -7,7 +122,110 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::get_runtime_management_config::GetRuntimeManagementConfigError::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   
        }
   43     40   
        "ResourceNotFoundException" => crate::operation::get_runtime_management_config::GetRuntimeManagementConfigError::ResourceNotFoundException({
   44     41   
            #[allow(unused_mut)]
   45     42   
            let mut tmp = {
   46     43   
                #[allow(unused_mut)]
   47     44   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   48     45   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   49     46   
                    .map_err(crate::operation::get_runtime_management_config::GetRuntimeManagementConfigError::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   
        "ServiceException" => crate::operation::get_runtime_management_config::GetRuntimeManagementConfigError::ServiceException({
   59     53   
            #[allow(unused_mut)]
   60     54   
            let mut tmp = {
   61     55   
                #[allow(unused_mut)]
   62     56   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   63     57   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   64     58   
                    .map_err(crate::operation::get_runtime_management_config::GetRuntimeManagementConfigError::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   
        "TooManyRequestsException" => crate::operation::get_runtime_management_config::GetRuntimeManagementConfigError::TooManyRequestsException({
   74     65   
            #[allow(unused_mut)]
   75     66   
            let mut tmp = {
   76     67   
                #[allow(unused_mut)]
   77     68   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   78     69   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   79     70   
                    .map_err(crate::operation::get_runtime_management_config::GetRuntimeManagementConfigError::unhandled)?;
   80     71   
                output = output.set_retry_after_seconds(
   81     72   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   82     73   
                        crate::operation::get_runtime_management_config::GetRuntimeManagementConfigError::unhandled(
   83     74   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   84     75   
                        )
   85     76   
                    })?,
   86     77   
                );
   87     78   
                let output = output.meta(generic);
   88     79   
                output.build()
   89     80   
            };
   90         -
            if tmp.message.is_none() {
   91         -
                tmp.message = _error_message;
   92         -
            }
   93     81   
            tmp
   94     82   
        }),
   95     83   
        _ => crate::operation::get_runtime_management_config::GetRuntimeManagementConfigError::generic(generic),
   96     84   
    })
   97     85   
}
   98     86   
   99     87   
#[allow(clippy::unnecessary_wraps)]
  100     88   
pub fn de_get_runtime_management_config_http_response(
  101     89   
    _response_status: u16,
  102     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_invoke.rs

@@ -1,1 +520,430 @@
   20     20   
        "EC2AccessDeniedException" => crate::operation::invoke::InvokeError::Ec2AccessDeniedException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::Ec2AccessDeniedExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_ec2_access_denied_exception::de_ec2_access_denied_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::invoke::InvokeError::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   
        "EC2ThrottledException" => crate::operation::invoke::InvokeError::Ec2ThrottledException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::Ec2ThrottledExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_ec2_throttled_exception::de_ec2_throttled_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::invoke::InvokeError::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   
        "EC2UnexpectedException" => crate::operation::invoke::InvokeError::Ec2UnexpectedException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::Ec2UnexpectedExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_ec2_unexpected_exception::de_ec2_unexpected_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::invoke::InvokeError::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   
        "EFSIOException" => crate::operation::invoke::InvokeError::EfsioException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::EfsioExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_efsio_exception::de_efsio_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::invoke::InvokeError::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   
        "EFSMountConnectivityException" => crate::operation::invoke::InvokeError::EfsMountConnectivityException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::EfsMountConnectivityExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_efs_mount_connectivity_exception::de_efs_mount_connectivity_exception_json_err(
   86     74   
                    _response_body,
   87     75   
                    output,
   88     76   
                )
   89     77   
                .map_err(crate::operation::invoke::InvokeError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        "EFSMountFailureException" => crate::operation::invoke::InvokeError::EfsMountFailureException({
   99     84   
            #[allow(unused_mut)]
  100     85   
            let mut tmp = {
  101     86   
                #[allow(unused_mut)]
  102     87   
                let mut output = crate::types::error::builders::EfsMountFailureExceptionBuilder::default();
  103     88   
                output = crate::protocol_serde::shape_efs_mount_failure_exception::de_efs_mount_failure_exception_json_err(_response_body, output)
  104     89   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  105     90   
                let output = output.meta(generic);
  106     91   
                output.build()
  107     92   
            };
  108         -
            if tmp.message.is_none() {
  109         -
                tmp.message = _error_message;
  110         -
            }
  111     93   
            tmp
  112     94   
        }),
  113     95   
        "EFSMountTimeoutException" => crate::operation::invoke::InvokeError::EfsMountTimeoutException({
  114     96   
            #[allow(unused_mut)]
  115     97   
            let mut tmp = {
  116     98   
                #[allow(unused_mut)]
  117     99   
                let mut output = crate::types::error::builders::EfsMountTimeoutExceptionBuilder::default();
  118    100   
                output = crate::protocol_serde::shape_efs_mount_timeout_exception::de_efs_mount_timeout_exception_json_err(_response_body, output)
  119    101   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  120    102   
                let output = output.meta(generic);
  121    103   
                output.build()
  122    104   
            };
  123         -
            if tmp.message.is_none() {
  124         -
                tmp.message = _error_message;
  125         -
            }
  126    105   
            tmp
  127    106   
        }),
  128    107   
        "ENILimitReachedException" => crate::operation::invoke::InvokeError::EniLimitReachedException({
  129    108   
            #[allow(unused_mut)]
  130    109   
            let mut tmp = {
  131    110   
                #[allow(unused_mut)]
  132    111   
                let mut output = crate::types::error::builders::EniLimitReachedExceptionBuilder::default();
  133    112   
                output = crate::protocol_serde::shape_eni_limit_reached_exception::de_eni_limit_reached_exception_json_err(_response_body, output)
  134    113   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  135    114   
                let output = output.meta(generic);
  136    115   
                output.build()
  137    116   
            };
  138         -
            if tmp.message.is_none() {
  139         -
                tmp.message = _error_message;
  140         -
            }
  141    117   
            tmp
  142    118   
        }),
  143    119   
        "InvalidParameterValueException" => crate::operation::invoke::InvokeError::InvalidParameterValueException({
  144    120   
            #[allow(unused_mut)]
  145    121   
            let mut tmp = {
  146    122   
                #[allow(unused_mut)]
  147    123   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
  148    124   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
  149    125   
                    _response_body,
  150    126   
                    output,
  151    127   
                )
  152    128   
                .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  153    129   
                let output = output.meta(generic);
  154    130   
                output.build()
  155    131   
            };
  156         -
            if tmp.message.is_none() {
  157         -
                tmp.message = _error_message;
  158         -
            }
  159    132   
            tmp
  160    133   
        }),
  161    134   
        "InvalidRequestContentException" => crate::operation::invoke::InvokeError::InvalidRequestContentException({
  162    135   
            #[allow(unused_mut)]
  163    136   
            let mut tmp = {
  164    137   
                #[allow(unused_mut)]
  165    138   
                let mut output = crate::types::error::builders::InvalidRequestContentExceptionBuilder::default();
  166    139   
                output = crate::protocol_serde::shape_invalid_request_content_exception::de_invalid_request_content_exception_json_err(
  167    140   
                    _response_body,
  168    141   
                    output,
  169    142   
                )
  170    143   
                .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  171    144   
                let output = output.meta(generic);
  172    145   
                output.build()
  173    146   
            };
  174         -
            if tmp.message.is_none() {
  175         -
                tmp.message = _error_message;
  176         -
            }
  177    147   
            tmp
  178    148   
        }),
  179    149   
        "InvalidRuntimeException" => crate::operation::invoke::InvokeError::InvalidRuntimeException({
  180    150   
            #[allow(unused_mut)]
  181    151   
            let mut tmp = {
  182    152   
                #[allow(unused_mut)]
  183    153   
                let mut output = crate::types::error::builders::InvalidRuntimeExceptionBuilder::default();
  184    154   
                output = crate::protocol_serde::shape_invalid_runtime_exception::de_invalid_runtime_exception_json_err(_response_body, output)
  185    155   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  186    156   
                let output = output.meta(generic);
  187    157   
                output.build()
  188    158   
            };
  189         -
            if tmp.message.is_none() {
  190         -
                tmp.message = _error_message;
  191         -
            }
  192    159   
            tmp
  193    160   
        }),
  194    161   
        "InvalidSecurityGroupIDException" => crate::operation::invoke::InvokeError::InvalidSecurityGroupIdException({
  195    162   
            #[allow(unused_mut)]
  196    163   
            let mut tmp = {
  197    164   
                #[allow(unused_mut)]
  198    165   
                let mut output = crate::types::error::builders::InvalidSecurityGroupIdExceptionBuilder::default();
  199    166   
                output = crate::protocol_serde::shape_invalid_security_group_id_exception::de_invalid_security_group_id_exception_json_err(
  200    167   
                    _response_body,
  201    168   
                    output,
  202    169   
                )
  203    170   
                .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  204    171   
                let output = output.meta(generic);
  205    172   
                output.build()
  206    173   
            };
  207         -
            if tmp.message.is_none() {
  208         -
                tmp.message = _error_message;
  209         -
            }
  210    174   
            tmp
  211    175   
        }),
  212    176   
        "InvalidSubnetIDException" => crate::operation::invoke::InvokeError::InvalidSubnetIdException({
  213    177   
            #[allow(unused_mut)]
  214    178   
            let mut tmp = {
  215    179   
                #[allow(unused_mut)]
  216    180   
                let mut output = crate::types::error::builders::InvalidSubnetIdExceptionBuilder::default();
  217    181   
                output = crate::protocol_serde::shape_invalid_subnet_id_exception::de_invalid_subnet_id_exception_json_err(_response_body, output)
  218    182   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  219    183   
                let output = output.meta(generic);
  220    184   
                output.build()
  221    185   
            };
  222         -
            if tmp.message.is_none() {
  223         -
                tmp.message = _error_message;
  224         -
            }
  225    186   
            tmp
  226    187   
        }),
  227    188   
        "InvalidZipFileException" => crate::operation::invoke::InvokeError::InvalidZipFileException({
  228    189   
            #[allow(unused_mut)]
  229    190   
            let mut tmp = {
  230    191   
                #[allow(unused_mut)]
  231    192   
                let mut output = crate::types::error::builders::InvalidZipFileExceptionBuilder::default();
  232    193   
                output = crate::protocol_serde::shape_invalid_zip_file_exception::de_invalid_zip_file_exception_json_err(_response_body, output)
  233    194   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  234    195   
                let output = output.meta(generic);
  235    196   
                output.build()
  236    197   
            };
  237         -
            if tmp.message.is_none() {
  238         -
                tmp.message = _error_message;
  239         -
            }
  240    198   
            tmp
  241    199   
        }),
  242    200   
        "KMSAccessDeniedException" => crate::operation::invoke::InvokeError::KmsAccessDeniedException({
  243    201   
            #[allow(unused_mut)]
  244    202   
            let mut tmp = {
  245    203   
                #[allow(unused_mut)]
  246    204   
                let mut output = crate::types::error::builders::KmsAccessDeniedExceptionBuilder::default();
  247    205   
                output = crate::protocol_serde::shape_kms_access_denied_exception::de_kms_access_denied_exception_json_err(_response_body, output)
  248    206   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  249    207   
                let output = output.meta(generic);
  250    208   
                output.build()
  251    209   
            };
  252         -
            if tmp.message.is_none() {
  253         -
                tmp.message = _error_message;
  254         -
            }
  255    210   
            tmp
  256    211   
        }),
  257    212   
        "KMSDisabledException" => crate::operation::invoke::InvokeError::KmsDisabledException({
  258    213   
            #[allow(unused_mut)]
  259    214   
            let mut tmp = {
  260    215   
                #[allow(unused_mut)]
  261    216   
                let mut output = crate::types::error::builders::KmsDisabledExceptionBuilder::default();
  262    217   
                output = crate::protocol_serde::shape_kms_disabled_exception::de_kms_disabled_exception_json_err(_response_body, output)
  263    218   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  264    219   
                let output = output.meta(generic);
  265    220   
                output.build()
  266    221   
            };
  267         -
            if tmp.message.is_none() {
  268         -
                tmp.message = _error_message;
  269         -
            }
  270    222   
            tmp
  271    223   
        }),
  272    224   
        "KMSInvalidStateException" => crate::operation::invoke::InvokeError::KmsInvalidStateException({
  273    225   
            #[allow(unused_mut)]
  274    226   
            let mut tmp = {
  275    227   
                #[allow(unused_mut)]
  276    228   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
  277    229   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
  278    230   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  279    231   
                let output = output.meta(generic);
  280    232   
                output.build()
  281    233   
            };
  282         -
            if tmp.message.is_none() {
  283         -
                tmp.message = _error_message;
  284         -
            }
  285    234   
            tmp
  286    235   
        }),
  287    236   
        "KMSNotFoundException" => crate::operation::invoke::InvokeError::KmsNotFoundException({
  288    237   
            #[allow(unused_mut)]
  289    238   
            let mut tmp = {
  290    239   
                #[allow(unused_mut)]
  291    240   
                let mut output = crate::types::error::builders::KmsNotFoundExceptionBuilder::default();
  292    241   
                output = crate::protocol_serde::shape_kms_not_found_exception::de_kms_not_found_exception_json_err(_response_body, output)
  293    242   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  294    243   
                let output = output.meta(generic);
  295    244   
                output.build()
  296    245   
            };
  297         -
            if tmp.message.is_none() {
  298         -
                tmp.message = _error_message;
  299         -
            }
  300    246   
            tmp
  301    247   
        }),
  302    248   
        "RecursiveInvocationException" => crate::operation::invoke::InvokeError::RecursiveInvocationException({
  303    249   
            #[allow(unused_mut)]
  304    250   
            let mut tmp = {
  305    251   
                #[allow(unused_mut)]
  306    252   
                let mut output = crate::types::error::builders::RecursiveInvocationExceptionBuilder::default();
  307    253   
                output =
  308    254   
                    crate::protocol_serde::shape_recursive_invocation_exception::de_recursive_invocation_exception_json_err(_response_body, output)
  309    255   
                        .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  310    256   
                let output = output.meta(generic);
  311    257   
                output.build()
  312    258   
            };
  313         -
            if tmp.message.is_none() {
  314         -
                tmp.message = _error_message;
  315         -
            }
  316    259   
            tmp
  317    260   
        }),
  318    261   
        "RequestTooLargeException" => crate::operation::invoke::InvokeError::RequestTooLargeException({
  319    262   
            #[allow(unused_mut)]
  320    263   
            let mut tmp = {
  321    264   
                #[allow(unused_mut)]
  322    265   
                let mut output = crate::types::error::builders::RequestTooLargeExceptionBuilder::default();
  323    266   
                output = crate::protocol_serde::shape_request_too_large_exception::de_request_too_large_exception_json_err(_response_body, output)
  324    267   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  325    268   
                let output = output.meta(generic);
  326    269   
                output.build()
  327    270   
            };
  328         -
            if tmp.message.is_none() {
  329         -
                tmp.message = _error_message;
  330         -
            }
  331    271   
            tmp
  332    272   
        }),
  333    273   
        "ResourceConflictException" => crate::operation::invoke::InvokeError::ResourceConflictException({
  334    274   
            #[allow(unused_mut)]
  335    275   
            let mut tmp = {
  336    276   
                #[allow(unused_mut)]
  337    277   
                let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
  338    278   
                output = crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
  339    279   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  340    280   
                let output = output.meta(generic);
  341    281   
                output.build()
  342    282   
            };
  343         -
            if tmp.message.is_none() {
  344         -
                tmp.message = _error_message;
  345         -
            }
  346    283   
            tmp
  347    284   
        }),
  348    285   
        "ResourceNotFoundException" => crate::operation::invoke::InvokeError::ResourceNotFoundException({
  349    286   
            #[allow(unused_mut)]
  350    287   
            let mut tmp = {
  351    288   
                #[allow(unused_mut)]
  352    289   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
  353    290   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  354    291   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  355    292   
                let output = output.meta(generic);
  356    293   
                output.build()
  357    294   
            };
  358         -
            if tmp.message.is_none() {
  359         -
                tmp.message = _error_message;
  360         -
            }
  361    295   
            tmp
  362    296   
        }),
  363    297   
        "ResourceNotReadyException" => crate::operation::invoke::InvokeError::ResourceNotReadyException({
  364    298   
            #[allow(unused_mut)]
  365    299   
            let mut tmp = {
  366    300   
                #[allow(unused_mut)]
  367    301   
                let mut output = crate::types::error::builders::ResourceNotReadyExceptionBuilder::default();
  368    302   
                output = crate::protocol_serde::shape_resource_not_ready_exception::de_resource_not_ready_exception_json_err(_response_body, output)
  369    303   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  370    304   
                let output = output.meta(generic);
  371    305   
                output.build()
  372    306   
            };
  373         -
            if tmp.message.is_none() {
  374         -
                tmp.message = _error_message;
  375         -
            }
  376    307   
            tmp
  377    308   
        }),
  378    309   
        "ServiceException" => crate::operation::invoke::InvokeError::ServiceException({
  379    310   
            #[allow(unused_mut)]
  380    311   
            let mut tmp = {
  381    312   
                #[allow(unused_mut)]
  382    313   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
  383    314   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
  384    315   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  385    316   
                let output = output.meta(generic);
  386    317   
                output.build()
  387    318   
            };
  388         -
            if tmp.message.is_none() {
  389         -
                tmp.message = _error_message;
  390         -
            }
  391    319   
            tmp
  392    320   
        }),
  393    321   
        "SnapStartException" => crate::operation::invoke::InvokeError::SnapStartException({
  394    322   
            #[allow(unused_mut)]
  395    323   
            let mut tmp = {
  396    324   
                #[allow(unused_mut)]
  397    325   
                let mut output = crate::types::error::builders::SnapStartExceptionBuilder::default();
  398    326   
                output = crate::protocol_serde::shape_snap_start_exception::de_snap_start_exception_json_err(_response_body, output)
  399    327   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  400    328   
                let output = output.meta(generic);
  401    329   
                output.build()
  402    330   
            };
  403         -
            if tmp.message.is_none() {
  404         -
                tmp.message = _error_message;
  405         -
            }
  406    331   
            tmp
  407    332   
        }),
  408    333   
        "SnapStartNotReadyException" => crate::operation::invoke::InvokeError::SnapStartNotReadyException({
  409    334   
            #[allow(unused_mut)]
  410    335   
            let mut tmp = {
  411    336   
                #[allow(unused_mut)]
  412    337   
                let mut output = crate::types::error::builders::SnapStartNotReadyExceptionBuilder::default();
  413    338   
                output =
  414    339   
                    crate::protocol_serde::shape_snap_start_not_ready_exception::de_snap_start_not_ready_exception_json_err(_response_body, output)
  415    340   
                        .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  416    341   
                let output = output.meta(generic);
  417    342   
                output.build()
  418    343   
            };
  419         -
            if tmp.message.is_none() {
  420         -
                tmp.message = _error_message;
  421         -
            }
  422    344   
            tmp
  423    345   
        }),
  424    346   
        "SnapStartTimeoutException" => crate::operation::invoke::InvokeError::SnapStartTimeoutException({
  425    347   
            #[allow(unused_mut)]
  426    348   
            let mut tmp = {
  427    349   
                #[allow(unused_mut)]
  428    350   
                let mut output = crate::types::error::builders::SnapStartTimeoutExceptionBuilder::default();
  429    351   
                output = crate::protocol_serde::shape_snap_start_timeout_exception::de_snap_start_timeout_exception_json_err(_response_body, output)
  430    352   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  431    353   
                let output = output.meta(generic);
  432    354   
                output.build()
  433    355   
            };
  434         -
            if tmp.message.is_none() {
  435         -
                tmp.message = _error_message;
  436         -
            }
  437    356   
            tmp
  438    357   
        }),
  439    358   
        "SubnetIPAddressLimitReachedException" => {
  440    359   
            crate::operation::invoke::InvokeError::SubnetIpAddressLimitReachedException({
  441    360   
                #[allow(unused_mut)]
  442    361   
                let mut tmp = {
  443    362   
                    #[allow(unused_mut)]
  444    363   
                    let mut output = crate::types::error::builders::SubnetIpAddressLimitReachedExceptionBuilder::default();
  445    364   
                    output = crate::protocol_serde::shape_subnet_ip_address_limit_reached_exception::de_subnet_ip_address_limit_reached_exception_json_err(_response_body, output).map_err(crate::operation::invoke::InvokeError::unhandled)?;
  446    365   
                    let output = output.meta(generic);
  447    366   
                    output.build()
  448    367   
                };
  449         -
                if tmp.message.is_none() {
  450         -
                    tmp.message = _error_message;
  451         -
                }
  452    368   
                tmp
  453    369   
            })
  454    370   
        }
  455    371   
        "TooManyRequestsException" => crate::operation::invoke::InvokeError::TooManyRequestsException({
  456    372   
            #[allow(unused_mut)]
  457    373   
            let mut tmp = {
  458    374   
                #[allow(unused_mut)]
  459    375   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
  460    376   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
  461    377   
                    .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  462    378   
                output = output.set_retry_after_seconds(
  463    379   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
  464    380   
                        crate::operation::invoke::InvokeError::unhandled("Failed to parse retryAfterSeconds from header `Retry-After")
  465    381   
                    })?,
  466    382   
                );
  467    383   
                let output = output.meta(generic);
  468    384   
                output.build()
  469    385   
            };
  470         -
            if tmp.message.is_none() {
  471         -
                tmp.message = _error_message;
  472         -
            }
  473    386   
            tmp
  474    387   
        }),
  475    388   
        "UnsupportedMediaTypeException" => crate::operation::invoke::InvokeError::UnsupportedMediaTypeException({
  476    389   
            #[allow(unused_mut)]
  477    390   
            let mut tmp = {
  478    391   
                #[allow(unused_mut)]
  479    392   
                let mut output = crate::types::error::builders::UnsupportedMediaTypeExceptionBuilder::default();
  480    393   
                output = crate::protocol_serde::shape_unsupported_media_type_exception::de_unsupported_media_type_exception_json_err(
  481    394   
                    _response_body,
  482    395   
                    output,
  483    396   
                )
  484    397   
                .map_err(crate::operation::invoke::InvokeError::unhandled)?;
  485    398   
                let output = output.meta(generic);
  486    399   
                output.build()
  487    400   
            };
  488         -
            if tmp.message.is_none() {
  489         -
                tmp.message = _error_message;
  490         -
            }
  491    401   
            tmp
  492    402   
        }),
  493    403   
        _ => crate::operation::invoke::InvokeError::generic(generic),
  494    404   
    })
  495    405   
}
  496    406   
  497    407   
#[allow(clippy::unnecessary_wraps)]
  498    408   
pub fn de_invoke_http_response(
  499    409   
    _response_status: u16,
  500    410   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_invoke_async.rs

@@ -3,3 +115,100 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidRequestContentExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_request_content_exception::de_invalid_request_content_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::invoke_async::InvokeAsyncError::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   
        "InvalidRuntimeException" => crate::operation::invoke_async::InvokeAsyncError::InvalidRuntimeException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidRuntimeExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_runtime_exception::de_invalid_runtime_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::invoke_async::InvokeAsyncError::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   
        "ResourceConflictException" => crate::operation::invoke_async::InvokeAsyncError::ResourceConflictException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::invoke_async::InvokeAsyncError::unhandled)?;
   60     54   
                let output = output.meta(generic);
   61     55   
                output.build()
   62     56   
            };
   63         -
            if tmp.message.is_none() {
   64         -
                tmp.message = _error_message;
   65         -
            }
   66     57   
            tmp
   67     58   
        }),
   68     59   
        "ResourceNotFoundException" => crate::operation::invoke_async::InvokeAsyncError::ResourceNotFoundException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::invoke_async::InvokeAsyncError::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   
        "ServiceException" => crate::operation::invoke_async::InvokeAsyncError::ServiceException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::invoke_async::InvokeAsyncError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        _ => crate::operation::invoke_async::InvokeAsyncError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_invoke_async_http_response(
  104     89   
    _response_status: u16,
  105     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,