AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05 (ignoring whitespace)

Files changed:

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

@@ -11,11 +141,126 @@
   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::put_function_concurrency::PutFunctionConcurrencyError::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   
        "ResourceConflictException" => crate::operation::put_function_concurrency::PutFunctionConcurrencyError::ResourceConflictException({
   48     45   
            #[allow(unused_mut)]
   49     46   
            let mut tmp = {
   50     47   
                #[allow(unused_mut)]
   51     48   
                let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   52     49   
                output = crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   53     50   
                    .map_err(crate::operation::put_function_concurrency::PutFunctionConcurrencyError::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   
        "ResourceNotFoundException" => crate::operation::put_function_concurrency::PutFunctionConcurrencyError::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 = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   68     62   
                    .map_err(crate::operation::put_function_concurrency::PutFunctionConcurrencyError::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   
        "ServiceException" => crate::operation::put_function_concurrency::PutFunctionConcurrencyError::ServiceException({
   78     69   
            #[allow(unused_mut)]
   79     70   
            let mut tmp = {
   80     71   
                #[allow(unused_mut)]
   81     72   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   82     73   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   83     74   
                    .map_err(crate::operation::put_function_concurrency::PutFunctionConcurrencyError::unhandled)?;
   84     75   
                let output = output.meta(generic);
   85     76   
                output.build()
   86     77   
            };
   87         -
            if tmp.message.is_none() {
   88         -
                tmp.message = _error_message;
   89         -
            }
   90     78   
            tmp
   91     79   
        }),
   92     80   
        "TooManyRequestsException" => crate::operation::put_function_concurrency::PutFunctionConcurrencyError::TooManyRequestsException({
   93     81   
            #[allow(unused_mut)]
   94     82   
            let mut tmp = {
   95     83   
                #[allow(unused_mut)]
   96     84   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   97     85   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   98     86   
                    .map_err(crate::operation::put_function_concurrency::PutFunctionConcurrencyError::unhandled)?;
   99     87   
                output = output.set_retry_after_seconds(
  100     88   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
  101     89   
                        crate::operation::put_function_concurrency::PutFunctionConcurrencyError::unhandled(
  102     90   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
  103     91   
                        )
  104     92   
                    })?,
  105     93   
                );
  106     94   
                let output = output.meta(generic);
  107     95   
                output.build()
  108     96   
            };
  109         -
            if tmp.message.is_none() {
  110         -
                tmp.message = _error_message;
  111         -
            }
  112     97   
            tmp
  113     98   
        }),
  114     99   
        _ => crate::operation::put_function_concurrency::PutFunctionConcurrencyError::generic(generic),
  115    100   
    })
  116    101   
}
  117    102   
  118    103   
#[allow(clippy::unnecessary_wraps)]
  119    104   
pub fn de_put_function_concurrency_http_response(
  120    105   
    _response_status: u16,
  121    106   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_put_function_event_invoke_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::put_function_event_invoke_config::PutFunctionEventInvokeConfigError::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   
        "ResourceConflictException" => {
   44     41   
            crate::operation::put_function_event_invoke_config::PutFunctionEventInvokeConfigError::ResourceConflictException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   49     46   
                    output =
   50     47   
                        crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   51     48   
                            .map_err(crate::operation::put_function_event_invoke_config::PutFunctionEventInvokeConfigError::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   
        "ResourceNotFoundException" => {
   62     56   
            crate::operation::put_function_event_invoke_config::PutFunctionEventInvokeConfigError::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::put_function_event_invoke_config::PutFunctionEventInvokeConfigError::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::put_function_event_invoke_config::PutFunctionEventInvokeConfigError::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::put_function_event_invoke_config::PutFunctionEventInvokeConfigError::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::put_function_event_invoke_config::PutFunctionEventInvokeConfigError::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::put_function_event_invoke_config::PutFunctionEventInvokeConfigError::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::put_function_event_invoke_config::PutFunctionEventInvokeConfigError::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::put_function_event_invoke_config::PutFunctionEventInvokeConfigError::generic(generic),
  120    105   
    })
  121    106   
}
  122    107   
  123    108   
#[allow(clippy::unnecessary_wraps)]
  124    109   
pub fn de_put_function_event_invoke_config_http_response(
  125    110   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_put_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::put_provisioned_concurrency_config::PutProvisionedConcurrencyConfigError::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   
        "ResourceConflictException" => {
   44     41   
            crate::operation::put_provisioned_concurrency_config::PutProvisionedConcurrencyConfigError::ResourceConflictException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   49     46   
                    output =
   50     47   
                        crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   51     48   
                            .map_err(crate::operation::put_provisioned_concurrency_config::PutProvisionedConcurrencyConfigError::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   
        "ResourceNotFoundException" => {
   62     56   
            crate::operation::put_provisioned_concurrency_config::PutProvisionedConcurrencyConfigError::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::put_provisioned_concurrency_config::PutProvisionedConcurrencyConfigError::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::put_provisioned_concurrency_config::PutProvisionedConcurrencyConfigError::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::put_provisioned_concurrency_config::PutProvisionedConcurrencyConfigError::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::put_provisioned_concurrency_config::PutProvisionedConcurrencyConfigError::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::put_provisioned_concurrency_config::PutProvisionedConcurrencyConfigError::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::put_provisioned_concurrency_config::PutProvisionedConcurrencyConfigError::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::put_provisioned_concurrency_config::PutProvisionedConcurrencyConfigError::generic(generic),
  120    105   
    })
  121    106   
}
  122    107   
  123    108   
#[allow(clippy::unnecessary_wraps)]
  124    109   
pub fn de_put_provisioned_concurrency_config_http_response(
  125    110   
    _response_status: u16,

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

@@ -7,7 +137,122 @@
   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::put_runtime_management_config::PutRuntimeManagementConfigError::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   
        "ResourceConflictException" => crate::operation::put_runtime_management_config::PutRuntimeManagementConfigError::ResourceConflictException({
   44     41   
            #[allow(unused_mut)]
   45     42   
            let mut tmp = {
   46     43   
                #[allow(unused_mut)]
   47     44   
                let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   48     45   
                output = crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   49     46   
                    .map_err(crate::operation::put_runtime_management_config::PutRuntimeManagementConfigError::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   
        "ResourceNotFoundException" => crate::operation::put_runtime_management_config::PutRuntimeManagementConfigError::ResourceNotFoundException({
   59     53   
            #[allow(unused_mut)]
   60     54   
            let mut tmp = {
   61     55   
                #[allow(unused_mut)]
   62     56   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   63     57   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   64     58   
                    .map_err(crate::operation::put_runtime_management_config::PutRuntimeManagementConfigError::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   
        "ServiceException" => crate::operation::put_runtime_management_config::PutRuntimeManagementConfigError::ServiceException({
   74     65   
            #[allow(unused_mut)]
   75     66   
            let mut tmp = {
   76     67   
                #[allow(unused_mut)]
   77     68   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   78     69   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   79     70   
                    .map_err(crate::operation::put_runtime_management_config::PutRuntimeManagementConfigError::unhandled)?;
   80     71   
                let output = output.meta(generic);
   81     72   
                output.build()
   82     73   
            };
   83         -
            if tmp.message.is_none() {
   84         -
                tmp.message = _error_message;
   85         -
            }
   86     74   
            tmp
   87     75   
        }),
   88     76   
        "TooManyRequestsException" => crate::operation::put_runtime_management_config::PutRuntimeManagementConfigError::TooManyRequestsException({
   89     77   
            #[allow(unused_mut)]
   90     78   
            let mut tmp = {
   91     79   
                #[allow(unused_mut)]
   92     80   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   93     81   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   94     82   
                    .map_err(crate::operation::put_runtime_management_config::PutRuntimeManagementConfigError::unhandled)?;
   95     83   
                output = output.set_retry_after_seconds(
   96     84   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   97     85   
                        crate::operation::put_runtime_management_config::PutRuntimeManagementConfigError::unhandled(
   98     86   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   99     87   
                        )
  100     88   
                    })?,
  101     89   
                );
  102     90   
                let output = output.meta(generic);
  103     91   
                output.build()
  104     92   
            };
  105         -
            if tmp.message.is_none() {
  106         -
                tmp.message = _error_message;
  107         -
            }
  108     93   
            tmp
  109     94   
        }),
  110     95   
        _ => crate::operation::put_runtime_management_config::PutRuntimeManagementConfigError::generic(generic),
  111     96   
    })
  112     97   
}
  113     98   
  114     99   
#[allow(clippy::unnecessary_wraps)]
  115    100   
pub fn de_put_runtime_management_config_http_response(
  116    101   
    _response_status: u16,
  117    102   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +138,123 @@
   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::remove_layer_version_permission::RemoveLayerVersionPermissionError::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   
        "PreconditionFailedException" => {
   44     41   
            crate::operation::remove_layer_version_permission::RemoveLayerVersionPermissionError::PreconditionFailedException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::PreconditionFailedExceptionBuilder::default();
   49     46   
                    output =
   50     47   
                        crate::protocol_serde::shape_precondition_failed_exception::de_precondition_failed_exception_json_err(_response_body, output)
   51     48   
                            .map_err(crate::operation::remove_layer_version_permission::RemoveLayerVersionPermissionError::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   
        "ResourceNotFoundException" => {
   62     56   
            crate::operation::remove_layer_version_permission::RemoveLayerVersionPermissionError::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::remove_layer_version_permission::RemoveLayerVersionPermissionError::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::remove_layer_version_permission::RemoveLayerVersionPermissionError::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::remove_layer_version_permission::RemoveLayerVersionPermissionError::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::remove_layer_version_permission::RemoveLayerVersionPermissionError::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::remove_layer_version_permission::RemoveLayerVersionPermissionError::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::remove_layer_version_permission::RemoveLayerVersionPermissionError::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::remove_layer_version_permission::RemoveLayerVersionPermissionError::generic(generic),
  120    105   
    })
  121    106   
}
  122    107   
  123    108   
#[allow(clippy::unnecessary_wraps)]
  124    109   
pub fn de_remove_layer_version_permission_http_response(
  125    110   
    _response_status: u16,

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

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

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

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

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

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

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

@@ -3,3 +146,128 @@
   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::update_alias::UpdateAliasError::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   
        "PreconditionFailedException" => crate::operation::update_alias::UpdateAliasError::PreconditionFailedException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::PreconditionFailedExceptionBuilder::default();
   43     40   
                output =
   44     41   
                    crate::protocol_serde::shape_precondition_failed_exception::de_precondition_failed_exception_json_err(_response_body, output)
   45     42   
                        .map_err(crate::operation::update_alias::UpdateAliasError::unhandled)?;
   46     43   
                let output = output.meta(generic);
   47     44   
                output.build()
   48     45   
            };
   49         -
            if tmp.message.is_none() {
   50         -
                tmp.message = _error_message;
   51         -
            }
   52     46   
            tmp
   53     47   
        }),
   54     48   
        "ResourceConflictException" => crate::operation::update_alias::UpdateAliasError::ResourceConflictException({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   60     54   
                    .map_err(crate::operation::update_alias::UpdateAliasError::unhandled)?;
   61     55   
                let output = output.meta(generic);
   62     56   
                output.build()
   63     57   
            };
   64         -
            if tmp.message.is_none() {
   65         -
                tmp.message = _error_message;
   66         -
            }
   67     58   
            tmp
   68     59   
        }),
   69     60   
        "ResourceNotFoundException" => crate::operation::update_alias::UpdateAliasError::ResourceNotFoundException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::update_alias::UpdateAliasError::unhandled)?;
   76     67   
                let output = output.meta(generic);
   77     68   
                output.build()
   78     69   
            };
   79         -
            if tmp.message.is_none() {
   80         -
                tmp.message = _error_message;
   81         -
            }
   82     70   
            tmp
   83     71   
        }),
   84     72   
        "ServiceException" => crate::operation::update_alias::UpdateAliasError::ServiceException({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   90     78   
                    .map_err(crate::operation::update_alias::UpdateAliasError::unhandled)?;
   91     79   
                let output = output.meta(generic);
   92     80   
                output.build()
   93     81   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     82   
            tmp
   98     83   
        }),
   99     84   
        "TooManyRequestsException" => crate::operation::update_alias::UpdateAliasError::TooManyRequestsException({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
  105     90   
                    .map_err(crate::operation::update_alias::UpdateAliasError::unhandled)?;
  106     91   
                output = output.set_retry_after_seconds(
  107     92   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
  108     93   
                        crate::operation::update_alias::UpdateAliasError::unhandled("Failed to parse retryAfterSeconds from header `Retry-After")
  109     94   
                    })?,
  110     95   
                );
  111     96   
                let output = output.meta(generic);
  112     97   
                output.build()
  113     98   
            };
  114         -
            if tmp.message.is_none() {
  115         -
                tmp.message = _error_message;
  116         -
            }
  117     99   
            tmp
  118    100   
        }),
  119    101   
        _ => crate::operation::update_alias::UpdateAliasError::generic(generic),
  120    102   
    })
  121    103   
}
  122    104   
  123    105   
#[allow(clippy::unnecessary_wraps)]
  124    106   
pub fn de_update_alias_http_response(
  125    107   
    _response_status: u16,
  126    108   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -11,11 +104,95 @@
   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::update_code_signing_config::UpdateCodeSigningConfigError::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::update_code_signing_config::UpdateCodeSigningConfigError::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::update_code_signing_config::UpdateCodeSigningConfigError::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::update_code_signing_config::UpdateCodeSigningConfigError::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::update_code_signing_config::UpdateCodeSigningConfigError::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   
        _ => crate::operation::update_code_signing_config::UpdateCodeSigningConfigError::generic(generic),
   78     69   
    })
   79     70   
}
   80     71   
   81     72   
#[allow(clippy::unnecessary_wraps)]
   82     73   
pub fn de_update_code_signing_config_http_response(
   83     74   
    _response_status: u16,
   84     75   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -11,11 +156,138 @@
   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::update_event_source_mapping::UpdateEventSourceMappingError::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   
        "ResourceConflictException" => crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::ResourceConflictException({
   48     45   
            #[allow(unused_mut)]
   49     46   
            let mut tmp = {
   50     47   
                #[allow(unused_mut)]
   51     48   
                let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   52     49   
                output = crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   53     50   
                    .map_err(crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::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   
        "ResourceInUseException" => crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::ResourceInUseException({
   63     57   
            #[allow(unused_mut)]
   64     58   
            let mut tmp = {
   65     59   
                #[allow(unused_mut)]
   66     60   
                let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
   67     61   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   68     62   
                    .map_err(crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::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   
        "ResourceNotFoundException" => crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::ResourceNotFoundException({
   78     69   
            #[allow(unused_mut)]
   79     70   
            let mut tmp = {
   80     71   
                #[allow(unused_mut)]
   81     72   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   82     73   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   83     74   
                    .map_err(crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::unhandled)?;
   84     75   
                let output = output.meta(generic);
   85     76   
                output.build()
   86     77   
            };
   87         -
            if tmp.message.is_none() {
   88         -
                tmp.message = _error_message;
   89         -
            }
   90     78   
            tmp
   91     79   
        }),
   92     80   
        "ServiceException" => crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::ServiceException({
   93     81   
            #[allow(unused_mut)]
   94     82   
            let mut tmp = {
   95     83   
                #[allow(unused_mut)]
   96     84   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   97     85   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   98     86   
                    .map_err(crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::unhandled)?;
   99     87   
                let output = output.meta(generic);
  100     88   
                output.build()
  101     89   
            };
  102         -
            if tmp.message.is_none() {
  103         -
                tmp.message = _error_message;
  104         -
            }
  105     90   
            tmp
  106     91   
        }),
  107     92   
        "TooManyRequestsException" => crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::TooManyRequestsException({
  108     93   
            #[allow(unused_mut)]
  109     94   
            let mut tmp = {
  110     95   
                #[allow(unused_mut)]
  111     96   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
  112     97   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
  113     98   
                    .map_err(crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::unhandled)?;
  114     99   
                output = output.set_retry_after_seconds(
  115    100   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
  116    101   
                        crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::unhandled(
  117    102   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
  118    103   
                        )
  119    104   
                    })?,
  120    105   
                );
  121    106   
                let output = output.meta(generic);
  122    107   
                output.build()
  123    108   
            };
  124         -
            if tmp.message.is_none() {
  125         -
                tmp.message = _error_message;
  126         -
            }
  127    109   
            tmp
  128    110   
        }),
  129    111   
        _ => crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::generic(generic),
  130    112   
    })
  131    113   
}
  132    114   
  133    115   
#[allow(clippy::unnecessary_wraps)]
  134    116   
pub fn de_update_event_source_mapping_http_response(
  135    117   
    _response_status: u16,
  136    118   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -8,8 +224,194 @@
   28     28   
                    let mut output = crate::types::error::builders::CodeSigningConfigNotFoundExceptionBuilder::default();
   29     29   
                    output =
   30     30   
                        crate::protocol_serde::shape_code_signing_config_not_found_exception::de_code_signing_config_not_found_exception_json_err(
   31     31   
                            _response_body,
   32     32   
                            output,
   33     33   
                        )
   34     34   
                        .map_err(crate::operation::update_function_code::UpdateFunctionCodeError::unhandled)?;
   35     35   
                    let output = output.meta(generic);
   36     36   
                    output.build()
   37     37   
                };
   38         -
                if tmp.message.is_none() {
   39         -
                    tmp.message = _error_message;
   40         -
                }
   41     38   
                tmp
   42     39   
            })
   43     40   
        }
   44     41   
        "CodeStorageExceededException" => crate::operation::update_function_code::UpdateFunctionCodeError::CodeStorageExceededException({
   45     42   
            #[allow(unused_mut)]
   46     43   
            let mut tmp = {
   47     44   
                #[allow(unused_mut)]
   48     45   
                let mut output = crate::types::error::builders::CodeStorageExceededExceptionBuilder::default();
   49     46   
                output =
   50     47   
                    crate::protocol_serde::shape_code_storage_exceeded_exception::de_code_storage_exceeded_exception_json_err(_response_body, output)
   51     48   
                        .map_err(crate::operation::update_function_code::UpdateFunctionCodeError::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   
        "CodeVerificationFailedException" => crate::operation::update_function_code::UpdateFunctionCodeError::CodeVerificationFailedException({
   61     55   
            #[allow(unused_mut)]
   62     56   
            let mut tmp = {
   63     57   
                #[allow(unused_mut)]
   64     58   
                let mut output = crate::types::error::builders::CodeVerificationFailedExceptionBuilder::default();
   65     59   
                output = crate::protocol_serde::shape_code_verification_failed_exception::de_code_verification_failed_exception_json_err(
   66     60   
                    _response_body,
   67     61   
                    output,
   68     62   
                )
   69     63   
                .map_err(crate::operation::update_function_code::UpdateFunctionCodeError::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   
        "InvalidCodeSignatureException" => crate::operation::update_function_code::UpdateFunctionCodeError::InvalidCodeSignatureException({
   79     70   
            #[allow(unused_mut)]
   80     71   
            let mut tmp = {
   81     72   
                #[allow(unused_mut)]
   82     73   
                let mut output = crate::types::error::builders::InvalidCodeSignatureExceptionBuilder::default();
   83     74   
                output = crate::protocol_serde::shape_invalid_code_signature_exception::de_invalid_code_signature_exception_json_err(
   84     75   
                    _response_body,
   85     76   
                    output,
   86     77   
                )
   87     78   
                .map_err(crate::operation::update_function_code::UpdateFunctionCodeError::unhandled)?;
   88     79   
                let output = output.meta(generic);
   89     80   
                output.build()
   90     81   
            };
   91         -
            if tmp.message.is_none() {
   92         -
                tmp.message = _error_message;
   93         -
            }
   94     82   
            tmp
   95     83   
        }),
   96     84   
        "InvalidParameterValueException" => crate::operation::update_function_code::UpdateFunctionCodeError::InvalidParameterValueException({
   97     85   
            #[allow(unused_mut)]
   98     86   
            let mut tmp = {
   99     87   
                #[allow(unused_mut)]
  100     88   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
  101     89   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
  102     90   
                    _response_body,
  103     91   
                    output,
  104     92   
                )
  105     93   
                .map_err(crate::operation::update_function_code::UpdateFunctionCodeError::unhandled)?;
  106     94   
                let output = output.meta(generic);
  107     95   
                output.build()
  108     96   
            };
  109         -
            if tmp.message.is_none() {
  110         -
                tmp.message = _error_message;
  111         -
            }
  112     97   
            tmp
  113     98   
        }),
  114     99   
        "PreconditionFailedException" => crate::operation::update_function_code::UpdateFunctionCodeError::PreconditionFailedException({
  115    100   
            #[allow(unused_mut)]
  116    101   
            let mut tmp = {
  117    102   
                #[allow(unused_mut)]
  118    103   
                let mut output = crate::types::error::builders::PreconditionFailedExceptionBuilder::default();
  119    104   
                output =
  120    105   
                    crate::protocol_serde::shape_precondition_failed_exception::de_precondition_failed_exception_json_err(_response_body, output)
  121    106   
                        .map_err(crate::operation::update_function_code::UpdateFunctionCodeError::unhandled)?;
  122    107   
                let output = output.meta(generic);
  123    108   
                output.build()
  124    109   
            };
  125         -
            if tmp.message.is_none() {
  126         -
                tmp.message = _error_message;
  127         -
            }
  128    110   
            tmp
  129    111   
        }),
  130    112   
        "ResourceConflictException" => crate::operation::update_function_code::UpdateFunctionCodeError::ResourceConflictException({
  131    113   
            #[allow(unused_mut)]
  132    114   
            let mut tmp = {
  133    115   
                #[allow(unused_mut)]
  134    116   
                let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
  135    117   
                output = crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
  136    118   
                    .map_err(crate::operation::update_function_code::UpdateFunctionCodeError::unhandled)?;
  137    119   
                let output = output.meta(generic);
  138    120   
                output.build()
  139    121   
            };
  140         -
            if tmp.message.is_none() {
  141         -
                tmp.message = _error_message;
  142         -
            }
  143    122   
            tmp
  144    123   
        }),
  145    124   
        "ResourceNotFoundException" => crate::operation::update_function_code::UpdateFunctionCodeError::ResourceNotFoundException({
  146    125   
            #[allow(unused_mut)]
  147    126   
            let mut tmp = {
  148    127   
                #[allow(unused_mut)]
  149    128   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
  150    129   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  151    130   
                    .map_err(crate::operation::update_function_code::UpdateFunctionCodeError::unhandled)?;
  152    131   
                let output = output.meta(generic);
  153    132   
                output.build()
  154    133   
            };
  155         -
            if tmp.message.is_none() {
  156         -
                tmp.message = _error_message;
  157         -
            }
  158    134   
            tmp
  159    135   
        }),
  160    136   
        "ServiceException" => crate::operation::update_function_code::UpdateFunctionCodeError::ServiceException({
  161    137   
            #[allow(unused_mut)]
  162    138   
            let mut tmp = {
  163    139   
                #[allow(unused_mut)]
  164    140   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
  165    141   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
  166    142   
                    .map_err(crate::operation::update_function_code::UpdateFunctionCodeError::unhandled)?;
  167    143   
                let output = output.meta(generic);
  168    144   
                output.build()
  169    145   
            };
  170         -
            if tmp.message.is_none() {
  171         -
                tmp.message = _error_message;
  172         -
            }
  173    146   
            tmp
  174    147   
        }),
  175    148   
        "TooManyRequestsException" => crate::operation::update_function_code::UpdateFunctionCodeError::TooManyRequestsException({
  176    149   
            #[allow(unused_mut)]
  177    150   
            let mut tmp = {
  178    151   
                #[allow(unused_mut)]
  179    152   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
  180    153   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
  181    154   
                    .map_err(crate::operation::update_function_code::UpdateFunctionCodeError::unhandled)?;
  182    155   
                output = output.set_retry_after_seconds(
  183    156   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
  184    157   
                        crate::operation::update_function_code::UpdateFunctionCodeError::unhandled(
  185    158   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
  186    159   
                        )
  187    160   
                    })?,
  188    161   
                );
  189    162   
                let output = output.meta(generic);
  190    163   
                output.build()
  191    164   
            };
  192         -
            if tmp.message.is_none() {
  193         -
                tmp.message = _error_message;
  194         -
            }
  195    165   
            tmp
  196    166   
        }),
  197    167   
        _ => crate::operation::update_function_code::UpdateFunctionCodeError::generic(generic),
  198    168   
    })
  199    169   
}
  200    170   
  201    171   
#[allow(clippy::unnecessary_wraps)]
  202    172   
pub fn de_update_function_code_http_response(
  203    173   
    _response_status: u16,
  204    174   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -8,8 +222,195 @@
   28     28   
                    let mut output = crate::types::error::builders::CodeSigningConfigNotFoundExceptionBuilder::default();
   29     29   
                    output =
   30     30   
                        crate::protocol_serde::shape_code_signing_config_not_found_exception::de_code_signing_config_not_found_exception_json_err(
   31     31   
                            _response_body,
   32     32   
                            output,
   33     33   
                        )
   34     34   
                        .map_err(crate::operation::update_function_configuration::UpdateFunctionConfigurationError::unhandled)?;
   35     35   
                    let output = output.meta(generic);
   36     36   
                    output.build()
   37     37   
                };
   38         -
                if tmp.message.is_none() {
   39         -
                    tmp.message = _error_message;
   40         -
                }
   41     38   
                tmp
   42     39   
            })
   43     40   
        }
   44     41   
        "CodeVerificationFailedException" => {
   45     42   
            crate::operation::update_function_configuration::UpdateFunctionConfigurationError::CodeVerificationFailedException({
   46     43   
                #[allow(unused_mut)]
   47     44   
                let mut tmp = {
   48     45   
                    #[allow(unused_mut)]
   49     46   
                    let mut output = crate::types::error::builders::CodeVerificationFailedExceptionBuilder::default();
   50     47   
                    output = crate::protocol_serde::shape_code_verification_failed_exception::de_code_verification_failed_exception_json_err(
   51     48   
                        _response_body,
   52     49   
                        output,
   53     50   
                    )
   54     51   
                    .map_err(crate::operation::update_function_configuration::UpdateFunctionConfigurationError::unhandled)?;
   55     52   
                    let output = output.meta(generic);
   56     53   
                    output.build()
   57     54   
                };
   58         -
                if tmp.message.is_none() {
   59         -
                    tmp.message = _error_message;
   60         -
                }
   61     55   
                tmp
   62     56   
            })
   63     57   
        }
   64     58   
        "InvalidCodeSignatureException" => {
   65     59   
            crate::operation::update_function_configuration::UpdateFunctionConfigurationError::InvalidCodeSignatureException({
   66     60   
                #[allow(unused_mut)]
   67     61   
                let mut tmp = {
   68     62   
                    #[allow(unused_mut)]
   69     63   
                    let mut output = crate::types::error::builders::InvalidCodeSignatureExceptionBuilder::default();
   70     64   
                    output = crate::protocol_serde::shape_invalid_code_signature_exception::de_invalid_code_signature_exception_json_err(
   71     65   
                        _response_body,
   72     66   
                        output,
   73     67   
                    )
   74     68   
                    .map_err(crate::operation::update_function_configuration::UpdateFunctionConfigurationError::unhandled)?;
   75     69   
                    let output = output.meta(generic);
   76     70   
                    output.build()
   77     71   
                };
   78         -
                if tmp.message.is_none() {
   79         -
                    tmp.message = _error_message;
   80         -
                }
   81     72   
                tmp
   82     73   
            })
   83     74   
        }
   84     75   
        "InvalidParameterValueException" => {
   85     76   
            crate::operation::update_function_configuration::UpdateFunctionConfigurationError::InvalidParameterValueException({
   86     77   
                #[allow(unused_mut)]
   87     78   
                let mut tmp = {
   88     79   
                    #[allow(unused_mut)]
   89     80   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   90     81   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   91     82   
                        _response_body,
   92     83   
                        output,
   93     84   
                    )
   94     85   
                    .map_err(crate::operation::update_function_configuration::UpdateFunctionConfigurationError::unhandled)?;
   95     86   
                    let output = output.meta(generic);
   96     87   
                    output.build()
   97     88   
                };
   98         -
                if tmp.message.is_none() {
   99         -
                    tmp.message = _error_message;
  100         -
                }
  101     89   
                tmp
  102     90   
            })
  103     91   
        }
  104     92   
        "PreconditionFailedException" => {
  105     93   
            crate::operation::update_function_configuration::UpdateFunctionConfigurationError::PreconditionFailedException({
  106     94   
                #[allow(unused_mut)]
  107     95   
                let mut tmp = {
  108     96   
                    #[allow(unused_mut)]
  109     97   
                    let mut output = crate::types::error::builders::PreconditionFailedExceptionBuilder::default();
  110     98   
                    output =
  111     99   
                        crate::protocol_serde::shape_precondition_failed_exception::de_precondition_failed_exception_json_err(_response_body, output)
  112    100   
                            .map_err(crate::operation::update_function_configuration::UpdateFunctionConfigurationError::unhandled)?;
  113    101   
                    let output = output.meta(generic);
  114    102   
                    output.build()
  115    103   
                };
  116         -
                if tmp.message.is_none() {
  117         -
                    tmp.message = _error_message;
  118         -
                }
  119    104   
                tmp
  120    105   
            })
  121    106   
        }
  122    107   
        "ResourceConflictException" => {
  123    108   
            crate::operation::update_function_configuration::UpdateFunctionConfigurationError::ResourceConflictException({
  124    109   
                #[allow(unused_mut)]
  125    110   
                let mut tmp = {
  126    111   
                    #[allow(unused_mut)]
  127    112   
                    let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
  128    113   
                    output =
  129    114   
                        crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
  130    115   
                            .map_err(crate::operation::update_function_configuration::UpdateFunctionConfigurationError::unhandled)?;
  131    116   
                    let output = output.meta(generic);
  132    117   
                    output.build()
  133    118   
                };
  134         -
                if tmp.message.is_none() {
  135         -
                    tmp.message = _error_message;
  136         -
                }
  137    119   
                tmp
  138    120   
            })
  139    121   
        }
  140    122   
        "ResourceNotFoundException" => {
  141    123   
            crate::operation::update_function_configuration::UpdateFunctionConfigurationError::ResourceNotFoundException({
  142    124   
                #[allow(unused_mut)]
  143    125   
                let mut tmp = {
  144    126   
                    #[allow(unused_mut)]
  145    127   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
  146    128   
                    output =
  147    129   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  148    130   
                            .map_err(crate::operation::update_function_configuration::UpdateFunctionConfigurationError::unhandled)?;
  149    131   
                    let output = output.meta(generic);
  150    132   
                    output.build()
  151    133   
                };
  152         -
                if tmp.message.is_none() {
  153         -
                    tmp.message = _error_message;
  154         -
                }
  155    134   
                tmp
  156    135   
            })
  157    136   
        }
  158    137   
        "ServiceException" => crate::operation::update_function_configuration::UpdateFunctionConfigurationError::ServiceException({
  159    138   
            #[allow(unused_mut)]
  160    139   
            let mut tmp = {
  161    140   
                #[allow(unused_mut)]
  162    141   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
  163    142   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
  164    143   
                    .map_err(crate::operation::update_function_configuration::UpdateFunctionConfigurationError::unhandled)?;
  165    144   
                let output = output.meta(generic);
  166    145   
                output.build()
  167    146   
            };
  168         -
            if tmp.message.is_none() {
  169         -
                tmp.message = _error_message;
  170         -
            }
  171    147   
            tmp
  172    148   
        }),
  173    149   
        "TooManyRequestsException" => crate::operation::update_function_configuration::UpdateFunctionConfigurationError::TooManyRequestsException({
  174    150   
            #[allow(unused_mut)]
  175    151   
            let mut tmp = {
  176    152   
                #[allow(unused_mut)]
  177    153   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
  178    154   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
  179    155   
                    .map_err(crate::operation::update_function_configuration::UpdateFunctionConfigurationError::unhandled)?;
  180    156   
                output = output.set_retry_after_seconds(
  181    157   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
  182    158   
                        crate::operation::update_function_configuration::UpdateFunctionConfigurationError::unhandled(
  183    159   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
  184    160   
                        )
  185    161   
                    })?,
  186    162   
                );
  187    163   
                let output = output.meta(generic);
  188    164   
                output.build()
  189    165   
            };
  190         -
            if tmp.message.is_none() {
  191         -
                tmp.message = _error_message;
  192         -
            }
  193    166   
            tmp
  194    167   
        }),
  195    168   
        _ => crate::operation::update_function_configuration::UpdateFunctionConfigurationError::generic(generic),
  196    169   
    })
  197    170   
}
  198    171   
  199    172   
#[allow(clippy::unnecessary_wraps)]
  200    173   
pub fn de_update_function_configuration_http_response(
  201    174   
    _response_status: u16,
  202    175   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_update_function_event_invoke_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::update_function_event_invoke_config::UpdateFunctionEventInvokeConfigError::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   
        "ResourceConflictException" => {
   44     41   
            crate::operation::update_function_event_invoke_config::UpdateFunctionEventInvokeConfigError::ResourceConflictException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   49     46   
                    output =
   50     47   
                        crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   51     48   
                            .map_err(crate::operation::update_function_event_invoke_config::UpdateFunctionEventInvokeConfigError::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   
        "ResourceNotFoundException" => {
   62     56   
            crate::operation::update_function_event_invoke_config::UpdateFunctionEventInvokeConfigError::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::update_function_event_invoke_config::UpdateFunctionEventInvokeConfigError::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::update_function_event_invoke_config::UpdateFunctionEventInvokeConfigError::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::update_function_event_invoke_config::UpdateFunctionEventInvokeConfigError::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::update_function_event_invoke_config::UpdateFunctionEventInvokeConfigError::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::update_function_event_invoke_config::UpdateFunctionEventInvokeConfigError::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::update_function_event_invoke_config::UpdateFunctionEventInvokeConfigError::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::update_function_event_invoke_config::UpdateFunctionEventInvokeConfigError::generic(generic),
  120    105   
    })
  121    106   
}
  122    107   
  123    108   
#[allow(clippy::unnecessary_wraps)]
  124    109   
pub fn de_update_function_event_invoke_config_http_response(
  125    110   
    _response_status: u16,

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

@@ -11,11 +141,126 @@
   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::update_function_url_config::UpdateFunctionUrlConfigError::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   
        "ResourceConflictException" => crate::operation::update_function_url_config::UpdateFunctionUrlConfigError::ResourceConflictException({
   48     45   
            #[allow(unused_mut)]
   49     46   
            let mut tmp = {
   50     47   
                #[allow(unused_mut)]
   51     48   
                let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   52     49   
                output = crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   53     50   
                    .map_err(crate::operation::update_function_url_config::UpdateFunctionUrlConfigError::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   
        "ResourceNotFoundException" => crate::operation::update_function_url_config::UpdateFunctionUrlConfigError::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 = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   68     62   
                    .map_err(crate::operation::update_function_url_config::UpdateFunctionUrlConfigError::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   
        "ServiceException" => crate::operation::update_function_url_config::UpdateFunctionUrlConfigError::ServiceException({
   78     69   
            #[allow(unused_mut)]
   79     70   
            let mut tmp = {
   80     71   
                #[allow(unused_mut)]
   81     72   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   82     73   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   83     74   
                    .map_err(crate::operation::update_function_url_config::UpdateFunctionUrlConfigError::unhandled)?;
   84     75   
                let output = output.meta(generic);
   85     76   
                output.build()
   86     77   
            };
   87         -
            if tmp.message.is_none() {
   88         -
                tmp.message = _error_message;
   89         -
            }
   90     78   
            tmp
   91     79   
        }),
   92     80   
        "TooManyRequestsException" => crate::operation::update_function_url_config::UpdateFunctionUrlConfigError::TooManyRequestsException({
   93     81   
            #[allow(unused_mut)]
   94     82   
            let mut tmp = {
   95     83   
                #[allow(unused_mut)]
   96     84   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   97     85   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   98     86   
                    .map_err(crate::operation::update_function_url_config::UpdateFunctionUrlConfigError::unhandled)?;
   99     87   
                output = output.set_retry_after_seconds(
  100     88   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
  101     89   
                        crate::operation::update_function_url_config::UpdateFunctionUrlConfigError::unhandled(
  102     90   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
  103     91   
                        )
  104     92   
                    })?,
  105     93   
                );
  106     94   
                let output = output.meta(generic);
  107     95   
                output.build()
  108     96   
            };
  109         -
            if tmp.message.is_none() {
  110         -
                tmp.message = _error_message;
  111         -
            }
  112     97   
            tmp
  113     98   
        }),
  114     99   
        _ => crate::operation::update_function_url_config::UpdateFunctionUrlConfigError::generic(generic),
  115    100   
    })
  116    101   
}
  117    102   
  118    103   
#[allow(clippy::unnecessary_wraps)]
  119    104   
pub fn de_update_function_url_config_http_response(
  120    105   
    _response_status: u16,
  121    106   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/polly/src/protocol_serde/shape_delete_lexicon.rs

@@ -1,1 +66,60 @@
   20     20   
        "LexiconNotFoundException" => crate::operation::delete_lexicon::DeleteLexiconError::LexiconNotFoundException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::LexiconNotFoundExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_lexicon_not_found_exception::de_lexicon_not_found_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::delete_lexicon::DeleteLexiconError::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   
        "ServiceFailureException" => crate::operation::delete_lexicon::DeleteLexiconError::ServiceFailureException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::delete_lexicon::DeleteLexiconError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        _ => crate::operation::delete_lexicon::DeleteLexiconError::generic(generic),
   51     45   
    })
   52     46   
}
   53     47   
   54     48   
#[allow(clippy::unnecessary_wraps)]
   55     49   
pub fn de_delete_lexicon_http_response(
   56     50   
    _response_status: u16,
   57     51   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,