AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05 (ignoring whitespace)

Files changed:

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

@@ -1,1 +77,71 @@
   20     20   
        "InvalidNextTokenException" => crate::operation::describe_voices::DescribeVoicesError::InvalidNextTokenException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::describe_voices::DescribeVoicesError::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::describe_voices::DescribeVoicesError::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::describe_voices::DescribeVoicesError::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::describe_voices::DescribeVoicesError::generic(generic),
   51     45   
    })
   52     46   
}
   53     47   
   54     48   
#[allow(clippy::unnecessary_wraps)]
   55     49   
pub fn de_describe_voices_http_response(
   56     50   
    _response_status: u16,
   57     51   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +77,71 @@
   20     20   
        "LexiconNotFoundException" => crate::operation::get_lexicon::GetLexiconError::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::get_lexicon::GetLexiconError::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::get_lexicon::GetLexiconError::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::get_lexicon::GetLexiconError::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::get_lexicon::GetLexiconError::generic(generic),
   51     45   
    })
   52     46   
}
   53     47   
   54     48   
#[allow(clippy::unnecessary_wraps)]
   55     49   
pub fn de_get_lexicon_http_response(
   56     50   
    _response_status: u16,
   57     51   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +103,94 @@
   27     27   
        "InvalidTaskIdException" => crate::operation::get_speech_synthesis_task::GetSpeechSynthesisTaskError::InvalidTaskIdException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::InvalidTaskIdExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_invalid_task_id_exception::de_invalid_task_id_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::get_speech_synthesis_task::GetSpeechSynthesisTaskError::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   
        "ServiceFailureException" => crate::operation::get_speech_synthesis_task::GetSpeechSynthesisTaskError::ServiceFailureException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::get_speech_synthesis_task::GetSpeechSynthesisTaskError::unhandled)?;
   49     46   
                let output = output.meta(generic);
   50     47   
                output.build()
   51     48   
            };
   52         -
            if tmp.message.is_none() {
   53         -
                tmp.message = _error_message;
   54         -
            }
   55     49   
            tmp
   56     50   
        }),
   57     51   
        "SynthesisTaskNotFoundException" => {
   58     52   
            crate::operation::get_speech_synthesis_task::GetSpeechSynthesisTaskError::SynthesisTaskNotFoundException({
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut tmp = {
   61     55   
                    #[allow(unused_mut)]
   62     56   
                    let mut output = crate::types::error::builders::SynthesisTaskNotFoundExceptionBuilder::default();
   63     57   
                    output = crate::protocol_serde::shape_synthesis_task_not_found_exception::de_synthesis_task_not_found_exception_json_err(
   64     58   
                        _response_body,
   65     59   
                        output,
   66     60   
                    )
   67     61   
                    .map_err(crate::operation::get_speech_synthesis_task::GetSpeechSynthesisTaskError::unhandled)?;
   68     62   
                    let output = output.meta(generic);
   69     63   
                    output.build()
   70     64   
                };
   71         -
                if tmp.message.is_none() {
   72         -
                    tmp.message = _error_message;
   73         -
                }
   74     65   
                tmp
   75     66   
            })
   76     67   
        }
   77     68   
        _ => crate::operation::get_speech_synthesis_task::GetSpeechSynthesisTaskError::generic(generic),
   78     69   
    })
   79     70   
}
   80     71   
   81     72   
#[allow(clippy::unnecessary_wraps)]
   82     73   
pub fn de_get_speech_synthesis_task_http_response(
   83     74   
    _response_status: u16,

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

@@ -1,1 +77,71 @@
   20     20   
        "InvalidNextTokenException" => crate::operation::list_lexicons::ListLexiconsError::InvalidNextTokenException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::list_lexicons::ListLexiconsError::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::list_lexicons::ListLexiconsError::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::list_lexicons::ListLexiconsError::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::list_lexicons::ListLexiconsError::generic(generic),
   51     45   
    })
   52     46   
}
   53     47   
   54     48   
#[allow(clippy::unnecessary_wraps)]
   55     49   
pub fn de_list_lexicons_http_response(
   56     50   
    _response_status: u16,
   57     51   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -7,7 +84,78 @@
   27     27   
        "InvalidNextTokenException" => crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError::InvalidNextTokenException({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError::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   
        "ServiceFailureException" => crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError::ServiceFailureException({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError::unhandled)?;
   49     46   
                let output = output.meta(generic);
   50     47   
                output.build()
   51     48   
            };
   52         -
            if tmp.message.is_none() {
   53         -
                tmp.message = _error_message;
   54         -
            }
   55     49   
            tmp
   56     50   
        }),
   57     51   
        _ => crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError::generic(generic),
   58     52   
    })
   59     53   
}
   60     54   
   61     55   
#[allow(clippy::unnecessary_wraps)]
   62     56   
pub fn de_list_speech_synthesis_tasks_http_response(
   63     57   
    _response_status: u16,
   64     58   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +164,143 @@
   20     20   
        "InvalidLexiconException" => crate::operation::put_lexicon::PutLexiconError::InvalidLexiconException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidLexiconExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_lexicon_exception::de_invalid_lexicon_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::put_lexicon::PutLexiconError::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   
        "LexiconSizeExceededException" => crate::operation::put_lexicon::PutLexiconError::LexiconSizeExceededException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::LexiconSizeExceededExceptionBuilder::default();
   40     37   
                output =
   41     38   
                    crate::protocol_serde::shape_lexicon_size_exceeded_exception::de_lexicon_size_exceeded_exception_json_err(_response_body, output)
   42     39   
                        .map_err(crate::operation::put_lexicon::PutLexiconError::unhandled)?;
   43     40   
                let output = output.meta(generic);
   44     41   
                output.build()
   45     42   
            };
   46         -
            if tmp.message.is_none() {
   47         -
                tmp.message = _error_message;
   48         -
            }
   49     43   
            tmp
   50     44   
        }),
   51     45   
        "MaxLexemeLengthExceededException" => crate::operation::put_lexicon::PutLexiconError::MaxLexemeLengthExceededException({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::MaxLexemeLengthExceededExceptionBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_max_lexeme_length_exceeded_exception::de_max_lexeme_length_exceeded_exception_json_err(
   57     51   
                    _response_body,
   58     52   
                    output,
   59     53   
                )
   60     54   
                .map_err(crate::operation::put_lexicon::PutLexiconError::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   
        "MaxLexiconsNumberExceededException" => crate::operation::put_lexicon::PutLexiconError::MaxLexiconsNumberExceededException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::MaxLexiconsNumberExceededExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_max_lexicons_number_exceeded_exception::de_max_lexicons_number_exceeded_exception_json_err(
   75     66   
                    _response_body,
   76     67   
                    output,
   77     68   
                )
   78     69   
                .map_err(crate::operation::put_lexicon::PutLexiconError::unhandled)?;
   79     70   
                let output = output.meta(generic);
   80     71   
                output.build()
   81     72   
            };
   82         -
            if tmp.message.is_none() {
   83         -
                tmp.message = _error_message;
   84         -
            }
   85     73   
            tmp
   86     74   
        }),
   87     75   
        "ServiceFailureException" => crate::operation::put_lexicon::PutLexiconError::ServiceFailureException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_json_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::put_lexicon::PutLexiconError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        "UnsupportedPlsAlphabetException" => crate::operation::put_lexicon::PutLexiconError::UnsupportedPlsAlphabetException({
  103     88   
            #[allow(unused_mut)]
  104     89   
            let mut tmp = {
  105     90   
                #[allow(unused_mut)]
  106     91   
                let mut output = crate::types::error::builders::UnsupportedPlsAlphabetExceptionBuilder::default();
  107     92   
                output = crate::protocol_serde::shape_unsupported_pls_alphabet_exception::de_unsupported_pls_alphabet_exception_json_err(
  108     93   
                    _response_body,
  109     94   
                    output,
  110     95   
                )
  111     96   
                .map_err(crate::operation::put_lexicon::PutLexiconError::unhandled)?;
  112     97   
                let output = output.meta(generic);
  113     98   
                output.build()
  114     99   
            };
  115         -
            if tmp.message.is_none() {
  116         -
                tmp.message = _error_message;
  117         -
            }
  118    100   
            tmp
  119    101   
        }),
  120    102   
        "UnsupportedPlsLanguageException" => crate::operation::put_lexicon::PutLexiconError::UnsupportedPlsLanguageException({
  121    103   
            #[allow(unused_mut)]
  122    104   
            let mut tmp = {
  123    105   
                #[allow(unused_mut)]
  124    106   
                let mut output = crate::types::error::builders::UnsupportedPlsLanguageExceptionBuilder::default();
  125    107   
                output = crate::protocol_serde::shape_unsupported_pls_language_exception::de_unsupported_pls_language_exception_json_err(
  126    108   
                    _response_body,
  127    109   
                    output,
  128    110   
                )
  129    111   
                .map_err(crate::operation::put_lexicon::PutLexiconError::unhandled)?;
  130    112   
                let output = output.meta(generic);
  131    113   
                output.build()
  132    114   
            };
  133         -
            if tmp.message.is_none() {
  134         -
                tmp.message = _error_message;
  135         -
            }
  136    115   
            tmp
  137    116   
        }),
  138    117   
        _ => crate::operation::put_lexicon::PutLexiconError::generic(generic),
  139    118   
    })
  140    119   
}
  141    120   
  142    121   
#[allow(clippy::unnecessary_wraps)]
  143    122   
pub fn de_put_lexicon_http_response(
  144    123   
    _response_status: u16,
  145    124   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -8,8 +250,214 @@
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::EngineNotSupportedExceptionBuilder::default();
   32     32   
                output =
   33     33   
                    crate::protocol_serde::shape_engine_not_supported_exception::de_engine_not_supported_exception_json_err(_response_body, output)
   34     34   
                        .map_err(crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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   
        "InvalidS3BucketException" => crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::InvalidS3BucketException({
   44     41   
            #[allow(unused_mut)]
   45     42   
            let mut tmp = {
   46     43   
                #[allow(unused_mut)]
   47     44   
                let mut output = crate::types::error::builders::InvalidS3BucketExceptionBuilder::default();
   48     45   
                output = crate::protocol_serde::shape_invalid_s3_bucket_exception::de_invalid_s3_bucket_exception_json_err(_response_body, output)
   49     46   
                    .map_err(crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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   
        "InvalidS3KeyException" => crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::InvalidS3KeyException({
   59     53   
            #[allow(unused_mut)]
   60     54   
            let mut tmp = {
   61     55   
                #[allow(unused_mut)]
   62     56   
                let mut output = crate::types::error::builders::InvalidS3KeyExceptionBuilder::default();
   63     57   
                output = crate::protocol_serde::shape_invalid_s3_key_exception::de_invalid_s3_key_exception_json_err(_response_body, output)
   64     58   
                    .map_err(crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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   
        "InvalidSampleRateException" => crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::InvalidSampleRateException({
   74     65   
            #[allow(unused_mut)]
   75     66   
            let mut tmp = {
   76     67   
                #[allow(unused_mut)]
   77     68   
                let mut output = crate::types::error::builders::InvalidSampleRateExceptionBuilder::default();
   78     69   
                output =
   79     70   
                    crate::protocol_serde::shape_invalid_sample_rate_exception::de_invalid_sample_rate_exception_json_err(_response_body, output)
   80     71   
                        .map_err(crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::unhandled)?;
   81     72   
                let output = output.meta(generic);
   82     73   
                output.build()
   83     74   
            };
   84         -
            if tmp.message.is_none() {
   85         -
                tmp.message = _error_message;
   86         -
            }
   87     75   
            tmp
   88     76   
        }),
   89     77   
        "InvalidSnsTopicArnException" => crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::InvalidSnsTopicArnException({
   90     78   
            #[allow(unused_mut)]
   91     79   
            let mut tmp = {
   92     80   
                #[allow(unused_mut)]
   93     81   
                let mut output = crate::types::error::builders::InvalidSnsTopicArnExceptionBuilder::default();
   94     82   
                output =
   95     83   
                    crate::protocol_serde::shape_invalid_sns_topic_arn_exception::de_invalid_sns_topic_arn_exception_json_err(_response_body, output)
   96     84   
                        .map_err(crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::unhandled)?;
   97     85   
                let output = output.meta(generic);
   98     86   
                output.build()
   99     87   
            };
  100         -
            if tmp.message.is_none() {
  101         -
                tmp.message = _error_message;
  102         -
            }
  103     88   
            tmp
  104     89   
        }),
  105     90   
        "InvalidSsmlException" => crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::InvalidSsmlException({
  106     91   
            #[allow(unused_mut)]
  107     92   
            let mut tmp = {
  108     93   
                #[allow(unused_mut)]
  109     94   
                let mut output = crate::types::error::builders::InvalidSsmlExceptionBuilder::default();
  110     95   
                output = crate::protocol_serde::shape_invalid_ssml_exception::de_invalid_ssml_exception_json_err(_response_body, output)
  111     96   
                    .map_err(crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::unhandled)?;
  112     97   
                let output = output.meta(generic);
  113     98   
                output.build()
  114     99   
            };
  115         -
            if tmp.message.is_none() {
  116         -
                tmp.message = _error_message;
  117         -
            }
  118    100   
            tmp
  119    101   
        }),
  120    102   
        "LanguageNotSupportedException" => {
  121    103   
            crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::LanguageNotSupportedException({
  122    104   
                #[allow(unused_mut)]
  123    105   
                let mut tmp = {
  124    106   
                    #[allow(unused_mut)]
  125    107   
                    let mut output = crate::types::error::builders::LanguageNotSupportedExceptionBuilder::default();
  126    108   
                    output = crate::protocol_serde::shape_language_not_supported_exception::de_language_not_supported_exception_json_err(
  127    109   
                        _response_body,
  128    110   
                        output,
  129    111   
                    )
  130    112   
                    .map_err(crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::unhandled)?;
  131    113   
                    let output = output.meta(generic);
  132    114   
                    output.build()
  133    115   
                };
  134         -
                if tmp.message.is_none() {
  135         -
                    tmp.message = _error_message;
  136         -
                }
  137    116   
                tmp
  138    117   
            })
  139    118   
        }
  140    119   
        "LexiconNotFoundException" => crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::LexiconNotFoundException({
  141    120   
            #[allow(unused_mut)]
  142    121   
            let mut tmp = {
  143    122   
                #[allow(unused_mut)]
  144    123   
                let mut output = crate::types::error::builders::LexiconNotFoundExceptionBuilder::default();
  145    124   
                output = crate::protocol_serde::shape_lexicon_not_found_exception::de_lexicon_not_found_exception_json_err(_response_body, output)
  146    125   
                    .map_err(crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::unhandled)?;
  147    126   
                let output = output.meta(generic);
  148    127   
                output.build()
  149    128   
            };
  150         -
            if tmp.message.is_none() {
  151         -
                tmp.message = _error_message;
  152         -
            }
  153    129   
            tmp
  154    130   
        }),
  155    131   
        "MarksNotSupportedForFormatException" => {
  156    132   
            crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::MarksNotSupportedForFormatException({
  157    133   
                #[allow(unused_mut)]
  158    134   
                let mut tmp = {
  159    135   
                    #[allow(unused_mut)]
  160    136   
                    let mut output = crate::types::error::builders::MarksNotSupportedForFormatExceptionBuilder::default();
  161    137   
                    output =
  162    138   
                        crate::protocol_serde::shape_marks_not_supported_for_format_exception::de_marks_not_supported_for_format_exception_json_err(
  163    139   
                            _response_body,
  164    140   
                            output,
  165    141   
                        )
  166    142   
                        .map_err(crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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   
        }
  176    149   
        "ServiceFailureException" => crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::ServiceFailureException({
  177    150   
            #[allow(unused_mut)]
  178    151   
            let mut tmp = {
  179    152   
                #[allow(unused_mut)]
  180    153   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
  181    154   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_json_err(_response_body, output)
  182    155   
                    .map_err(crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::unhandled)?;
  183    156   
                let output = output.meta(generic);
  184    157   
                output.build()
  185    158   
            };
  186         -
            if tmp.message.is_none() {
  187         -
                tmp.message = _error_message;
  188         -
            }
  189    159   
            tmp
  190    160   
        }),
  191    161   
        "SsmlMarksNotSupportedForTextTypeException" => {
  192    162   
            crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::SsmlMarksNotSupportedForTextTypeException({
  193    163   
                #[allow(unused_mut)]
  194    164   
                let mut tmp = {
  195    165   
                    #[allow(unused_mut)]
  196    166   
                    let mut output = crate::types::error::builders::SsmlMarksNotSupportedForTextTypeExceptionBuilder::default();
  197    167   
                    output = crate::protocol_serde::shape_ssml_marks_not_supported_for_text_type_exception::de_ssml_marks_not_supported_for_text_type_exception_json_err(_response_body, output).map_err(crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::unhandled)?;
  198    168   
                    let output = output.meta(generic);
  199    169   
                    output.build()
  200    170   
                };
  201         -
                if tmp.message.is_none() {
  202         -
                    tmp.message = _error_message;
  203         -
                }
  204    171   
                tmp
  205    172   
            })
  206    173   
        }
  207    174   
        "TextLengthExceededException" => crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::TextLengthExceededException({
  208    175   
            #[allow(unused_mut)]
  209    176   
            let mut tmp = {
  210    177   
                #[allow(unused_mut)]
  211    178   
                let mut output = crate::types::error::builders::TextLengthExceededExceptionBuilder::default();
  212    179   
                output =
  213    180   
                    crate::protocol_serde::shape_text_length_exceeded_exception::de_text_length_exceeded_exception_json_err(_response_body, output)
  214    181   
                        .map_err(crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::unhandled)?;
  215    182   
                let output = output.meta(generic);
  216    183   
                output.build()
  217    184   
            };
  218         -
            if tmp.message.is_none() {
  219         -
                tmp.message = _error_message;
  220         -
            }
  221    185   
            tmp
  222    186   
        }),
  223    187   
        _ => crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::generic(generic),
  224    188   
    })
  225    189   
}
  226    190   
  227    191   
#[allow(clippy::unnecessary_wraps)]
  228    192   
pub fn de_start_speech_synthesis_task_http_response(
  229    193   
    _response_status: u16,
  230    194   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -34,34 +210,183 @@
   54     54   
            #[allow(unused_mut)]
   55     55   
            let mut tmp = {
   56     56   
                #[allow(unused_mut)]
   57     57   
                let mut output = crate::types::error::builders::EngineNotSupportedExceptionBuilder::default();
   58     58   
                output =
   59     59   
                    crate::protocol_serde::shape_engine_not_supported_exception::de_engine_not_supported_exception_json_err(_response_body, output)
   60     60   
                        .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
   61     61   
                let output = output.meta(generic);
   62     62   
                output.build()
   63     63   
            };
   64         -
            if tmp.message.is_none() {
   65         -
                tmp.message = _error_message;
   66         -
            }
   67     64   
            tmp
   68     65   
        }),
   69     66   
        "InvalidSampleRateException" => crate::operation::synthesize_speech::SynthesizeSpeechError::InvalidSampleRateException({
   70     67   
            #[allow(unused_mut)]
   71     68   
            let mut tmp = {
   72     69   
                #[allow(unused_mut)]
   73     70   
                let mut output = crate::types::error::builders::InvalidSampleRateExceptionBuilder::default();
   74     71   
                output =
   75     72   
                    crate::protocol_serde::shape_invalid_sample_rate_exception::de_invalid_sample_rate_exception_json_err(_response_body, output)
   76     73   
                        .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
   77     74   
                let output = output.meta(generic);
   78     75   
                output.build()
   79     76   
            };
   80         -
            if tmp.message.is_none() {
   81         -
                tmp.message = _error_message;
   82         -
            }
   83     77   
            tmp
   84     78   
        }),
   85     79   
        "InvalidSsmlException" => crate::operation::synthesize_speech::SynthesizeSpeechError::InvalidSsmlException({
   86     80   
            #[allow(unused_mut)]
   87     81   
            let mut tmp = {
   88     82   
                #[allow(unused_mut)]
   89     83   
                let mut output = crate::types::error::builders::InvalidSsmlExceptionBuilder::default();
   90     84   
                output = crate::protocol_serde::shape_invalid_ssml_exception::de_invalid_ssml_exception_json_err(_response_body, output)
   91     85   
                    .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
   92     86   
                let output = output.meta(generic);
   93     87   
                output.build()
   94     88   
            };
   95         -
            if tmp.message.is_none() {
   96         -
                tmp.message = _error_message;
   97         -
            }
   98     89   
            tmp
   99     90   
        }),
  100     91   
        "LanguageNotSupportedException" => crate::operation::synthesize_speech::SynthesizeSpeechError::LanguageNotSupportedException({
  101     92   
            #[allow(unused_mut)]
  102     93   
            let mut tmp = {
  103     94   
                #[allow(unused_mut)]
  104     95   
                let mut output = crate::types::error::builders::LanguageNotSupportedExceptionBuilder::default();
  105     96   
                output = crate::protocol_serde::shape_language_not_supported_exception::de_language_not_supported_exception_json_err(
  106     97   
                    _response_body,
  107     98   
                    output,
  108     99   
                )
  109    100   
                .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
  110    101   
                let output = output.meta(generic);
  111    102   
                output.build()
  112    103   
            };
  113         -
            if tmp.message.is_none() {
  114         -
                tmp.message = _error_message;
  115         -
            }
  116    104   
            tmp
  117    105   
        }),
  118    106   
        "LexiconNotFoundException" => crate::operation::synthesize_speech::SynthesizeSpeechError::LexiconNotFoundException({
  119    107   
            #[allow(unused_mut)]
  120    108   
            let mut tmp = {
  121    109   
                #[allow(unused_mut)]
  122    110   
                let mut output = crate::types::error::builders::LexiconNotFoundExceptionBuilder::default();
  123    111   
                output = crate::protocol_serde::shape_lexicon_not_found_exception::de_lexicon_not_found_exception_json_err(_response_body, output)
  124    112   
                    .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
  125    113   
                let output = output.meta(generic);
  126    114   
                output.build()
  127    115   
            };
  128         -
            if tmp.message.is_none() {
  129         -
                tmp.message = _error_message;
  130         -
            }
  131    116   
            tmp
  132    117   
        }),
  133    118   
        "MarksNotSupportedForFormatException" => crate::operation::synthesize_speech::SynthesizeSpeechError::MarksNotSupportedForFormatException({
  134    119   
            #[allow(unused_mut)]
  135    120   
            let mut tmp = {
  136    121   
                #[allow(unused_mut)]
  137    122   
                let mut output = crate::types::error::builders::MarksNotSupportedForFormatExceptionBuilder::default();
  138    123   
                output = crate::protocol_serde::shape_marks_not_supported_for_format_exception::de_marks_not_supported_for_format_exception_json_err(
  139    124   
                    _response_body,
  140    125   
                    output,
  141    126   
                )
  142    127   
                .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
  143    128   
                let output = output.meta(generic);
  144    129   
                output.build()
  145    130   
            };
  146         -
            if tmp.message.is_none() {
  147         -
                tmp.message = _error_message;
  148         -
            }
  149    131   
            tmp
  150    132   
        }),
  151    133   
        "ServiceFailureException" => crate::operation::synthesize_speech::SynthesizeSpeechError::ServiceFailureException({
  152    134   
            #[allow(unused_mut)]
  153    135   
            let mut tmp = {
  154    136   
                #[allow(unused_mut)]
  155    137   
                let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
  156    138   
                output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_json_err(_response_body, output)
  157    139   
                    .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
  158    140   
                let output = output.meta(generic);
  159    141   
                output.build()
  160    142   
            };
  161         -
            if tmp.message.is_none() {
  162         -
                tmp.message = _error_message;
  163         -
            }
  164    143   
            tmp
  165    144   
        }),
  166    145   
        "SsmlMarksNotSupportedForTextTypeException" => {
  167    146   
            crate::operation::synthesize_speech::SynthesizeSpeechError::SsmlMarksNotSupportedForTextTypeException({
  168    147   
                #[allow(unused_mut)]
  169    148   
                let mut tmp = {
  170    149   
                    #[allow(unused_mut)]
  171    150   
                    let mut output = crate::types::error::builders::SsmlMarksNotSupportedForTextTypeExceptionBuilder::default();
  172    151   
                    output = crate::protocol_serde::shape_ssml_marks_not_supported_for_text_type_exception::de_ssml_marks_not_supported_for_text_type_exception_json_err(_response_body, output).map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
  173    152   
                    let output = output.meta(generic);
  174    153   
                    output.build()
  175    154   
                };
  176         -
                if tmp.message.is_none() {
  177         -
                    tmp.message = _error_message;
  178         -
                }
  179    155   
                tmp
  180    156   
            })
  181    157   
        }
  182    158   
        "TextLengthExceededException" => crate::operation::synthesize_speech::SynthesizeSpeechError::TextLengthExceededException({
  183    159   
            #[allow(unused_mut)]
  184    160   
            let mut tmp = {
  185    161   
                #[allow(unused_mut)]
  186    162   
                let mut output = crate::types::error::builders::TextLengthExceededExceptionBuilder::default();
  187    163   
                output =
  188    164   
                    crate::protocol_serde::shape_text_length_exceeded_exception::de_text_length_exceeded_exception_json_err(_response_body, output)
  189    165   
                        .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
  190    166   
                let output = output.meta(generic);
  191    167   
                output.build()
  192    168   
            };
  193         -
            if tmp.message.is_none() {
  194         -
                tmp.message = _error_message;
  195         -
            }
  196    169   
            tmp
  197    170   
        }),
  198    171   
        _ => crate::operation::synthesize_speech::SynthesizeSpeechError::generic(generic),
  199    172   
    })
  200    173   
}
  201    174   
  202    175   
pub fn ser_synthesize_speech_input(
  203    176   
    input: &crate::operation::synthesize_speech::SynthesizeSpeechInput,
  204    177   
) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
  205    178   
    let mut out = String::new();

tmp-codegen-diff/aws-sdk/sdk/qldbsession/src/protocol_serde/shape_send_command.rs

@@ -1,1 +137,119 @@
   20     20   
        "BadRequestException" => crate::operation::send_command::SendCommandError::BadRequestException({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::BadRequestExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_bad_request_exception::de_bad_request_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::send_command::SendCommandError::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   
        "CapacityExceededException" => crate::operation::send_command::SendCommandError::CapacityExceededException({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::CapacityExceededExceptionBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_capacity_exceeded_exception::de_capacity_exceeded_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::send_command::SendCommandError::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   
        "InvalidSessionException" => crate::operation::send_command::SendCommandError::InvalidSessionException({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidSessionExceptionBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_session_exception::de_invalid_session_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::send_command::SendCommandError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "LimitExceededException" => crate::operation::send_command::SendCommandError::LimitExceededException({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::send_command::SendCommandError::unhandled)?;
   72     63   
                let output = output.meta(generic);
   73     64   
                output.build()
   74     65   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     66   
            tmp
   79     67   
        }),
   80     68   
        "OccConflictException" => crate::operation::send_command::SendCommandError::OccConflictException({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::OccConflictExceptionBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_occ_conflict_exception::de_occ_conflict_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::send_command::SendCommandError::unhandled)?;
   87     75   
                let output = output.meta(generic);
   88     76   
                output.build()
   89     77   
            };
   90         -
            if tmp.message.is_none() {
   91         -
                tmp.message = _error_message;
   92         -
            }
   93     78   
            tmp
   94     79   
        }),
   95     80   
        "RateExceededException" => crate::operation::send_command::SendCommandError::RateExceededException({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::RateExceededExceptionBuilder::default();
  100     85   
                output = crate::protocol_serde::shape_rate_exceeded_exception::de_rate_exceeded_exception_json_err(_response_body, output)
  101     86   
                    .map_err(crate::operation::send_command::SendCommandError::unhandled)?;
  102     87   
                let output = output.meta(generic);
  103     88   
                output.build()
  104     89   
            };
  105         -
            if tmp.message.is_none() {
  106         -
                tmp.message = _error_message;
  107         -
            }
  108     90   
            tmp
  109     91   
        }),
  110     92   
        _ => crate::operation::send_command::SendCommandError::generic(generic),
  111     93   
    })
  112     94   
}
  113     95   
  114     96   
#[allow(clippy::unnecessary_wraps)]
  115     97   
pub fn de_send_command_http_response(
  116     98   
    _response_status: u16,
  117     99   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_activate_key_signing_key.rs

@@ -3,3 +141,123 @@
   23     23   
        "ConcurrentModification" => crate::operation::activate_key_signing_key::ActivateKeySigningKeyError::ConcurrentModification({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ConcurrentModificationBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_concurrent_modification::de_concurrent_modification_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::activate_key_signing_key::ActivateKeySigningKeyError::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   
        "InvalidInput" => crate::operation::activate_key_signing_key::ActivateKeySigningKeyError::InvalidInput({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::activate_key_signing_key::ActivateKeySigningKeyError::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   
        "InvalidKeySigningKeyStatus" => crate::operation::activate_key_signing_key::ActivateKeySigningKeyError::InvalidKeySigningKeyStatus({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidKeySigningKeyStatusBuilder::default();
   58     52   
                output =
   59     53   
                    crate::protocol_serde::shape_invalid_key_signing_key_status::de_invalid_key_signing_key_status_xml_err(_response_body, output)
   60     54   
                        .map_err(crate::operation::activate_key_signing_key::ActivateKeySigningKeyError::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   
        "InvalidKMSArn" => crate::operation::activate_key_signing_key::ActivateKeySigningKeyError::InvalidKmsArn({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::InvalidKmsArnBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_invalid_kms_arn::de_invalid_kms_arn_xml_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::activate_key_signing_key::ActivateKeySigningKeyError::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   
        "InvalidSigningStatus" => crate::operation::activate_key_signing_key::ActivateKeySigningKeyError::InvalidSigningStatus({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::InvalidSigningStatusBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_invalid_signing_status::de_invalid_signing_status_xml_err(_response_body, output)
   90     78   
                    .map_err(crate::operation::activate_key_signing_key::ActivateKeySigningKeyError::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   
        "NoSuchKeySigningKey" => crate::operation::activate_key_signing_key::ActivateKeySigningKeyError::NoSuchKeySigningKey({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::NoSuchKeySigningKeyBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_no_such_key_signing_key::de_no_such_key_signing_key_xml_err(_response_body, output)
  105     90   
                    .map_err(crate::operation::activate_key_signing_key::ActivateKeySigningKeyError::unhandled)?;
  106     91   
                let output = output.meta(generic);
  107     92   
                output.build()
  108     93   
            };
  109         -
            if tmp.message.is_none() {
  110         -
                tmp.message = _error_message;
  111         -
            }
  112     94   
            tmp
  113     95   
        }),
  114     96   
        _ => crate::operation::activate_key_signing_key::ActivateKeySigningKeyError::generic(generic),
  115     97   
    })
  116     98   
}
  117     99   
  118    100   
#[allow(clippy::unnecessary_wraps)]
  119    101   
pub fn de_activate_key_signing_key_http_response(
  120    102   
    _response_status: u16,
  121    103   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_associate_vpc_with_hosted_zone.rs

@@ -3,3 +170,146 @@
   23     23   
        "ConflictingDomainExists" => crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::ConflictingDomainExists({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ConflictingDomainExistsBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_conflicting_domain_exists::de_conflicting_domain_exists_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::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   
        "InvalidInput" => crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::InvalidInput({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::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   
        "InvalidVPCId" => crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::InvalidVpcId({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidVpcIdBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_vpc_id::de_invalid_vpc_id_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::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   
        "LimitsExceeded" => crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::LimitsExceeded({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::LimitsExceededBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_limits_exceeded::de_limits_exceeded_xml_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::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   
        "NoSuchHostedZone" => crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::NoSuchHostedZone({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        "NotAuthorizedException" => crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::NotAuthorizedException({
   99     84   
            #[allow(unused_mut)]
  100     85   
            let mut tmp = {
  101     86   
                #[allow(unused_mut)]
  102     87   
                let mut output = crate::types::error::builders::NotAuthorizedExceptionBuilder::default();
  103     88   
                output = crate::protocol_serde::shape_not_authorized_exception::de_not_authorized_exception_xml_err(_response_body, output)
  104     89   
                    .map_err(crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::unhandled)?;
  105     90   
                let output = output.meta(generic);
  106     91   
                output.build()
  107     92   
            };
  108         -
            if tmp.message.is_none() {
  109         -
                tmp.message = _error_message;
  110         -
            }
  111     93   
            tmp
  112     94   
        }),
  113     95   
        "PriorRequestNotComplete" => crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::PriorRequestNotComplete({
  114     96   
            #[allow(unused_mut)]
  115     97   
            let mut tmp = {
  116     98   
                #[allow(unused_mut)]
  117     99   
                let mut output = crate::types::error::builders::PriorRequestNotCompleteBuilder::default();
  118    100   
                output = crate::protocol_serde::shape_prior_request_not_complete::de_prior_request_not_complete_xml_err(_response_body, output)
  119    101   
                    .map_err(crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::unhandled)?;
  120    102   
                let output = output.meta(generic);
  121    103   
                output.build()
  122    104   
            };
  123         -
            if tmp.message.is_none() {
  124         -
                tmp.message = _error_message;
  125         -
            }
  126    105   
            tmp
  127    106   
        }),
  128    107   
        "PublicZoneVPCAssociation" => crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::PublicZoneVpcAssociation({
  129    108   
            #[allow(unused_mut)]
  130    109   
            let mut tmp = {
  131    110   
                #[allow(unused_mut)]
  132    111   
                let mut output = crate::types::error::builders::PublicZoneVpcAssociationBuilder::default();
  133    112   
                output = crate::protocol_serde::shape_public_zone_vpc_association::de_public_zone_vpc_association_xml_err(_response_body, output)
  134    113   
                    .map_err(crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::unhandled)?;
  135    114   
                let output = output.meta(generic);
  136    115   
                output.build()
  137    116   
            };
  138         -
            if tmp.message.is_none() {
  139         -
                tmp.message = _error_message;
  140         -
            }
  141    117   
            tmp
  142    118   
        }),
  143    119   
        _ => crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError::generic(generic),
  144    120   
    })
  145    121   
}
  146    122   
  147    123   
#[allow(clippy::unnecessary_wraps)]
  148    124   
pub fn de_associate_vpc_with_hosted_zone_http_response(
  149    125   
    _response_status: u16,
  150    126   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_change_cidr_collection.rs

@@ -3,3 +144,126 @@
   23     23   
        "CidrBlockInUseException" => crate::operation::change_cidr_collection::ChangeCidrCollectionError::CidrBlockInUseException({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::CidrBlockInUseExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_cidr_block_in_use_exception::de_cidr_block_in_use_exception_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::change_cidr_collection::ChangeCidrCollectionError::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   
        "CidrCollectionVersionMismatchException" => {
   39     36   
            crate::operation::change_cidr_collection::ChangeCidrCollectionError::CidrCollectionVersionMismatchException({
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut tmp = {
   42     39   
                    #[allow(unused_mut)]
   43     40   
                    let mut output = crate::types::error::builders::CidrCollectionVersionMismatchExceptionBuilder::default();
   44     41   
                    output = crate::protocol_serde::shape_cidr_collection_version_mismatch_exception::de_cidr_collection_version_mismatch_exception_xml_err(_response_body, output).map_err(crate::operation::change_cidr_collection::ChangeCidrCollectionError::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   
        }
   54     48   
        "ConcurrentModification" => crate::operation::change_cidr_collection::ChangeCidrCollectionError::ConcurrentModification({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::ConcurrentModificationBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_concurrent_modification::de_concurrent_modification_xml_err(_response_body, output)
   60     54   
                    .map_err(crate::operation::change_cidr_collection::ChangeCidrCollectionError::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   
        "InvalidInput" => crate::operation::change_cidr_collection::ChangeCidrCollectionError::InvalidInput({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::change_cidr_collection::ChangeCidrCollectionError::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   
        "LimitsExceeded" => crate::operation::change_cidr_collection::ChangeCidrCollectionError::LimitsExceeded({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::LimitsExceededBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_limits_exceeded::de_limits_exceeded_xml_err(_response_body, output)
   90     78   
                    .map_err(crate::operation::change_cidr_collection::ChangeCidrCollectionError::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   
        "NoSuchCidrCollectionException" => crate::operation::change_cidr_collection::ChangeCidrCollectionError::NoSuchCidrCollectionException({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::NoSuchCidrCollectionExceptionBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_no_such_cidr_collection_exception::de_no_such_cidr_collection_exception_xml_err(
  105     90   
                    _response_body,
  106     91   
                    output,
  107     92   
                )
  108     93   
                .map_err(crate::operation::change_cidr_collection::ChangeCidrCollectionError::unhandled)?;
  109     94   
                let output = output.meta(generic);
  110     95   
                output.build()
  111     96   
            };
  112         -
            if tmp.message.is_none() {
  113         -
                tmp.message = _error_message;
  114         -
            }
  115     97   
            tmp
  116     98   
        }),
  117     99   
        _ => crate::operation::change_cidr_collection::ChangeCidrCollectionError::generic(generic),
  118    100   
    })
  119    101   
}
  120    102   
  121    103   
#[allow(clippy::unnecessary_wraps)]
  122    104   
pub fn de_change_cidr_collection_http_response(
  123    105   
    _response_status: u16,
  124    106   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_change_resource_record_sets.rs

@@ -7,7 +129,114 @@
   27     27   
        "InvalidChangeBatch" => crate::operation::change_resource_record_sets::ChangeResourceRecordSetsError::InvalidChangeBatch({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::InvalidChangeBatchBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_invalid_change_batch::de_invalid_change_batch_xml_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::change_resource_record_sets::ChangeResourceRecordSetsError::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   
        "InvalidInput" => crate::operation::change_resource_record_sets::ChangeResourceRecordSetsError::InvalidInput({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::change_resource_record_sets::ChangeResourceRecordSetsError::unhandled)?;
   49     46   
                let output = output.meta(generic);
   50     47   
                output.build()
   51     48   
            };
   52         -
            if tmp.message.is_none() {
   53         -
                tmp.message = _error_message;
   54         -
            }
   55     49   
            tmp
   56     50   
        }),
   57     51   
        "NoSuchHealthCheck" => crate::operation::change_resource_record_sets::ChangeResourceRecordSetsError::NoSuchHealthCheck({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::NoSuchHealthCheckBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_no_such_health_check::de_no_such_health_check_xml_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::change_resource_record_sets::ChangeResourceRecordSetsError::unhandled)?;
   64     58   
                let output = output.meta(generic);
   65     59   
                output.build()
   66     60   
            };
   67         -
            if tmp.message.is_none() {
   68         -
                tmp.message = _error_message;
   69         -
            }
   70     61   
            tmp
   71     62   
        }),
   72     63   
        "NoSuchHostedZone" => crate::operation::change_resource_record_sets::ChangeResourceRecordSetsError::NoSuchHostedZone({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::change_resource_record_sets::ChangeResourceRecordSetsError::unhandled)?;
   79     70   
                let output = output.meta(generic);
   80     71   
                output.build()
   81     72   
            };
   82         -
            if tmp.message.is_none() {
   83         -
                tmp.message = _error_message;
   84         -
            }
   85     73   
            tmp
   86     74   
        }),
   87     75   
        "PriorRequestNotComplete" => crate::operation::change_resource_record_sets::ChangeResourceRecordSetsError::PriorRequestNotComplete({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::PriorRequestNotCompleteBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_prior_request_not_complete::de_prior_request_not_complete_xml_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::change_resource_record_sets::ChangeResourceRecordSetsError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        _ => crate::operation::change_resource_record_sets::ChangeResourceRecordSetsError::generic(generic),
  103     88   
    })
  104     89   
}
  105     90   
  106     91   
#[allow(clippy::unnecessary_wraps)]
  107     92   
pub fn de_change_resource_record_sets_http_response(
  108     93   
    _response_status: u16,
  109     94   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_change_tags_for_resource.rs

@@ -3,3 +125,110 @@
   23     23   
        "InvalidInput" => crate::operation::change_tags_for_resource::ChangeTagsForResourceError::InvalidInput({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::change_tags_for_resource::ChangeTagsForResourceError::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   
        "NoSuchHealthCheck" => crate::operation::change_tags_for_resource::ChangeTagsForResourceError::NoSuchHealthCheck({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::NoSuchHealthCheckBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_no_such_health_check::de_no_such_health_check_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::change_tags_for_resource::ChangeTagsForResourceError::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   
        "NoSuchHostedZone" => crate::operation::change_tags_for_resource::ChangeTagsForResourceError::NoSuchHostedZone({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::change_tags_for_resource::ChangeTagsForResourceError::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   
        "PriorRequestNotComplete" => crate::operation::change_tags_for_resource::ChangeTagsForResourceError::PriorRequestNotComplete({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::PriorRequestNotCompleteBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_prior_request_not_complete::de_prior_request_not_complete_xml_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::change_tags_for_resource::ChangeTagsForResourceError::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   
        "ThrottlingException" => crate::operation::change_tags_for_resource::ChangeTagsForResourceError::ThrottlingException({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   88     76   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_xml_err(_response_body, output)
   89     77   
                    .map_err(crate::operation::change_tags_for_resource::ChangeTagsForResourceError::unhandled)?;
   90     78   
                let output = output.meta(generic);
   91     79   
                output.build()
   92     80   
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96     81   
            tmp
   97     82   
        }),
   98     83   
        _ => crate::operation::change_tags_for_resource::ChangeTagsForResourceError::generic(generic),
   99     84   
    })
  100     85   
}
  101     86   
  102     87   
#[allow(clippy::unnecessary_wraps)]
  103     88   
pub fn de_change_tags_for_resource_http_response(
  104     89   
    _response_status: u16,
  105     90   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_create_cidr_collection.rs

@@ -8,8 +116,104 @@
   28     28   
                    let mut output = crate::types::error::builders::CidrCollectionAlreadyExistsExceptionBuilder::default();
   29     29   
                    output =
   30     30   
                        crate::protocol_serde::shape_cidr_collection_already_exists_exception::de_cidr_collection_already_exists_exception_xml_err(
   31     31   
                            _response_body,
   32     32   
                            output,
   33     33   
                        )
   34     34   
                        .map_err(crate::operation::create_cidr_collection::CreateCidrCollectionError::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   
        "ConcurrentModification" => crate::operation::create_cidr_collection::CreateCidrCollectionError::ConcurrentModification({
   45     42   
            #[allow(unused_mut)]
   46     43   
            let mut tmp = {
   47     44   
                #[allow(unused_mut)]
   48     45   
                let mut output = crate::types::error::builders::ConcurrentModificationBuilder::default();
   49     46   
                output = crate::protocol_serde::shape_concurrent_modification::de_concurrent_modification_xml_err(_response_body, output)
   50     47   
                    .map_err(crate::operation::create_cidr_collection::CreateCidrCollectionError::unhandled)?;
   51     48   
                let output = output.meta(generic);
   52     49   
                output.build()
   53     50   
            };
   54         -
            if tmp.message.is_none() {
   55         -
                tmp.message = _error_message;
   56         -
            }
   57     51   
            tmp
   58     52   
        }),
   59     53   
        "InvalidInput" => crate::operation::create_cidr_collection::CreateCidrCollectionError::InvalidInput({
   60     54   
            #[allow(unused_mut)]
   61     55   
            let mut tmp = {
   62     56   
                #[allow(unused_mut)]
   63     57   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   64     58   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   65     59   
                    .map_err(crate::operation::create_cidr_collection::CreateCidrCollectionError::unhandled)?;
   66     60   
                let output = output.meta(generic);
   67     61   
                output.build()
   68     62   
            };
   69         -
            if tmp.message.is_none() {
   70         -
                tmp.message = _error_message;
   71         -
            }
   72     63   
            tmp
   73     64   
        }),
   74     65   
        "LimitsExceeded" => crate::operation::create_cidr_collection::CreateCidrCollectionError::LimitsExceeded({
   75     66   
            #[allow(unused_mut)]
   76     67   
            let mut tmp = {
   77     68   
                #[allow(unused_mut)]
   78     69   
                let mut output = crate::types::error::builders::LimitsExceededBuilder::default();
   79     70   
                output = crate::protocol_serde::shape_limits_exceeded::de_limits_exceeded_xml_err(_response_body, output)
   80     71   
                    .map_err(crate::operation::create_cidr_collection::CreateCidrCollectionError::unhandled)?;
   81     72   
                let output = output.meta(generic);
   82     73   
                output.build()
   83     74   
            };
   84         -
            if tmp.message.is_none() {
   85         -
                tmp.message = _error_message;
   86         -
            }
   87     75   
            tmp
   88     76   
        }),
   89     77   
        _ => crate::operation::create_cidr_collection::CreateCidrCollectionError::generic(generic),
   90     78   
    })
   91     79   
}
   92     80   
   93     81   
#[allow(clippy::unnecessary_wraps)]
   94     82   
pub fn de_create_cidr_collection_http_response(
   95     83   
    _response_status: u16,
   96     84   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_create_health_check.rs

@@ -1,1 +93,84 @@
   21     21   
        "HealthCheckAlreadyExists" => crate::operation::create_health_check::CreateHealthCheckError::HealthCheckAlreadyExists({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::HealthCheckAlreadyExistsBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_health_check_already_exists::de_health_check_already_exists_xml_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::create_health_check::CreateHealthCheckError::unhandled)?;
   28     28   
                let output = output.meta(generic);
   29     29   
                output.build()
   30     30   
            };
   31         -
            if tmp.message.is_none() {
   32         -
                tmp.message = _error_message;
   33         -
            }
   34     31   
            tmp
   35     32   
        }),
   36     33   
        "InvalidInput" => crate::operation::create_health_check::CreateHealthCheckError::InvalidInput({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::create_health_check::CreateHealthCheckError::unhandled)?;
   43     40   
                let output = output.meta(generic);
   44     41   
                output.build()
   45     42   
            };
   46         -
            if tmp.message.is_none() {
   47         -
                tmp.message = _error_message;
   48         -
            }
   49     43   
            tmp
   50     44   
        }),
   51     45   
        "TooManyHealthChecks" => crate::operation::create_health_check::CreateHealthCheckError::TooManyHealthChecks({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::TooManyHealthChecksBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_too_many_health_checks::de_too_many_health_checks_xml_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::create_health_check::CreateHealthCheckError::unhandled)?;
   58     52   
                let output = output.meta(generic);
   59     53   
                output.build()
   60     54   
            };
   61         -
            if tmp.message.is_none() {
   62         -
                tmp.message = _error_message;
   63         -
            }
   64     55   
            tmp
   65     56   
        }),
   66     57   
        _ => crate::operation::create_health_check::CreateHealthCheckError::generic(generic),
   67     58   
    })
   68     59   
}
   69     60   
   70     61   
#[allow(clippy::unnecessary_wraps)]
   71     62   
pub fn de_create_health_check_http_response(
   72     63   
    _response_status: u16,
   73     64   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,