AWS SDK

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

@@ -1,0 +55,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub fn ser_start_speech_synthesis_task_input_input(
     object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
     input: &crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskInput,
 ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
     if let Some(var_1) = &input.engine {
         object.key("Engine").string(var_1.as_str());
--
+    }
     if let Some(var_2) = &input.language_code {
         object.key("LanguageCode").string(var_2.as_str());
--
+    }
     if let Some(var_3) = &input.lexicon_names {
         let mut array_4 = object.key("LexiconNames").start_array();
         for item_5 in var_3 {
--
+            {
                 array_4.value().string(item_5.as_str());
--
+            }
--
+        }
         array_4.finish();
--
+    }
     if let Some(var_6) = &input.output_format {
         object.key("OutputFormat").string(var_6.as_str());
--
+    }
     if let Some(var_7) = &input.output_s3_bucket_name {
         object.key("OutputS3BucketName").string(var_7.as_str());
--
+    }
     if let Some(var_8) = &input.output_s3_key_prefix {
         object.key("OutputS3KeyPrefix").string(var_8.as_str());
--
+    }
     if let Some(var_9) = &input.sample_rate {
         object.key("SampleRate").string(var_9.as_str());
--
+    }
     if let Some(var_10) = &input.sns_topic_arn {
         object.key("SnsTopicArn").string(var_10.as_str());
--
+    }
     if let Some(var_11) = &input.speech_mark_types {
         let mut array_12 = object.key("SpeechMarkTypes").start_array();
         for item_13 in var_11 {
--
+            {
                 array_12.value().string(item_13.as_str());
--
+            }
--
+        }
         array_12.finish();
--
+    }
     if let Some(var_14) = &input.text {
         object.key("Text").string(var_14.as_str());
--
+    }
     if let Some(var_15) = &input.text_type {
         object.key("TextType").string(var_15.as_str());
--
+    }
     if let Some(var_16) = &input.voice_id {
         object.key("VoiceId").string(var_16.as_str());
--
+    }
     Ok(())
--
+}

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

@@ -1,0 +132,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_synthesis_task<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
     _value: &'a [u8],
 ) -> ::std::result::Result<Option<crate::types::SynthesisTask>, ::aws_smithy_json::deserialize::error::DeserializeError>
 where
     I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>,
--
+{
     match tokens.next().transpose()? {
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
             #[allow(unused_mut)]
             let mut builder = crate::types::builders::SynthesisTaskBuilder::default();
             loop {
                 match tokens.next().transpose()? {
                     Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
                     Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                         "Engine" => {
                             builder = builder.set_engine(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| crate::types::Engine::from(u.as_ref())))
                                     .transpose()?,
                             );
--
+                        }
                         "TaskId" => {
                             builder = builder.set_task_id(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                     .transpose()?,
                             );
--
+                        }
                         "TaskStatus" => {
                             builder = builder.set_task_status(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| crate::types::TaskStatus::from(u.as_ref())))
                                     .transpose()?,
                             );
--
+                        }
                         "TaskStatusReason" => {
                             builder = builder.set_task_status_reason(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                     .transpose()?,
                             );
--
+                        }
                         "OutputUri" => {
                             builder = builder.set_output_uri(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                     .transpose()?,
                             );
--
+                        }
                         "CreationTime" => {
                             builder = builder.set_creation_time(::aws_smithy_json::deserialize::token::expect_timestamp_or_null(
                                 tokens.next(),
                                 ::aws_smithy_types::date_time::Format::EpochSeconds,
                             )?);
--
+                        }
                         "RequestCharacters" => {
                             builder = builder.set_request_characters(
                                 ::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
                                     .map(i32::try_from)
                                     .transpose()?,
                             );
--
+                        }
                         "SnsTopicArn" => {
                             builder = builder.set_sns_topic_arn(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                     .transpose()?,
                             );
--
+                        }
                         "LexiconNames" => {
                             builder =
                                 builder.set_lexicon_names(crate::protocol_serde::shape_lexicon_name_list::de_lexicon_name_list(tokens, _value)?);
--
+                        }
                         "OutputFormat" => {
                             builder = builder.set_output_format(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| crate::types::OutputFormat::from(u.as_ref())))
                                     .transpose()?,
                             );
--
+                        }
                         "SampleRate" => {
                             builder = builder.set_sample_rate(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                     .transpose()?,
                             );
--
+                        }
                         "SpeechMarkTypes" => {
                             builder = builder.set_speech_mark_types(crate::protocol_serde::shape_speech_mark_type_list::de_speech_mark_type_list(
                                 tokens, _value,
                             )?);
--
+                        }
                         "TextType" => {
                             builder = builder.set_text_type(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| crate::types::TextType::from(u.as_ref())))
                                     .transpose()?,
                             );
--
+                        }
                         "VoiceId" => {
                             builder = builder.set_voice_id(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| crate::types::VoiceId::from(u.as_ref())))
                                     .transpose()?,
                             );
--
+                        }
                         "LanguageCode" => {
                             builder = builder.set_language_code(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| crate::types::LanguageCode::from(u.as_ref())))
                                     .transpose()?,
                             );
--
+                        }
                         _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
                     },
                     other => {
                         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                             "expected object key or end object, found: {other:?}"
                         )))
--
+                    }
--
+                }
--
+            }
             Ok(Some(builder.build()))
--
+        }
         _ => Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "expected start object or null",
         )),
--
+    }
--
+}

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

@@ -1,0 +38,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_synthesis_task_not_found_exception_json_err(
     _value: &[u8],
     mut builder: crate::types::error::builders::SynthesisTaskNotFoundExceptionBuilder,
 ) -> ::std::result::Result<
     crate::types::error::builders::SynthesisTaskNotFoundExceptionBuilder,
     ::aws_smithy_json::deserialize::error::DeserializeError,
 > {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "message" => {
                     builder = builder.set_message(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

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

@@ -1,0 +37,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_synthesis_tasks<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
     _value: &'a [u8],
 ) -> ::std::result::Result<Option<::std::vec::Vec<crate::types::SynthesisTask>>, ::aws_smithy_json::deserialize::error::DeserializeError>
 where
     I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>,
--
+{
     match tokens.next().transpose()? {
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
             let mut items = Vec::new();
             loop {
                 match tokens.peek() {
                     Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
                         tokens.next().transpose().unwrap();
                         break;
--
+                    }
                     _ => {
                         let value = crate::protocol_serde::shape_synthesis_task::de_synthesis_task(tokens, _value)?;
                         if let Some(value) = value {
                             items.push(value);
                         } else {
                             return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                 "dense list cannot contain null values",
                             ));
--
+                        }
--
+                    }
--
+                }
--
+            }
             Ok(Some(items))
--
+        }
         _ => Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "expected start array or null",
         )),
--
+    }
--
+}

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

@@ -4,4 +210,0 @@

↥ Expand context

     response: &mut ::aws_smithy_runtime_api::http::Response,
 ) -> std::result::Result<crate::operation::synthesize_speech::SynthesizeSpeechOutput, crate::operation::synthesize_speech::SynthesizeSpeechError> {
     let mut _response_body = ::aws_smithy_types::body::SdkBody::taken();
     std::mem::swap(&mut _response_body, response.body_mut());
     let _response_body = &mut _response_body;
-9
     let _response_status = response.status().as_u16();
     let _response_headers = response.headers();
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::synthesize_speech::builders::SynthesizeSpeechOutputBuilder::default();
         output = output.set_audio_stream(Some(crate::protocol_serde::shape_synthesize_speech_output::de_audio_stream_payload(
             _response_body,
         )?));
         output = output.set_content_type(
             crate::protocol_serde::shape_synthesize_speech_output::de_content_type_header(_response_headers).map_err(|_| {
                 crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled("Failed to parse ContentType from header `Content-Type")
             })?,
         );
         output = output.set_request_characters(

             crate::protocol_serde::shape_synthesize_speech_output::de_request_characters_header(_response_headers).map_err(|_| {
                 crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled(
                     "Failed to parse RequestCharacters from header `x-amzn-RequestCharacters",
-27
+                )
             })?,
         );
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
-33
+}
--
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_synthesize_speech_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::synthesize_speech::SynthesizeSpeechOutput, crate::operation::synthesize_speech::SynthesizeSpeechError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled(generic)),
     };
--
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {
         "EngineNotSupportedException" => crate::operation::synthesize_speech::SynthesizeSpeechError::EngineNotSupportedException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::EngineNotSupportedExceptionBuilder::default();
                 output =
                     crate::protocol_serde::shape_engine_not_supported_exception::de_engine_not_supported_exception_json_err(_response_body, output)
                         .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "InvalidSampleRateException" => crate::operation::synthesize_speech::SynthesizeSpeechError::InvalidSampleRateException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidSampleRateExceptionBuilder::default();
                 output =
                     crate::protocol_serde::shape_invalid_sample_rate_exception::de_invalid_sample_rate_exception_json_err(_response_body, output)
                         .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "InvalidSsmlException" => crate::operation::synthesize_speech::SynthesizeSpeechError::InvalidSsmlException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidSsmlExceptionBuilder::default();
                 output = crate::protocol_serde::shape_invalid_ssml_exception::de_invalid_ssml_exception_json_err(_response_body, output)
                     .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "LanguageNotSupportedException" => crate::operation::synthesize_speech::SynthesizeSpeechError::LanguageNotSupportedException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::LanguageNotSupportedExceptionBuilder::default();
                 output = crate::protocol_serde::shape_language_not_supported_exception::de_language_not_supported_exception_json_err(
                     _response_body,
                     output,
--
+                )
                 .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "LexiconNotFoundException" => crate::operation::synthesize_speech::SynthesizeSpeechError::LexiconNotFoundException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::LexiconNotFoundExceptionBuilder::default();
                 output = crate::protocol_serde::shape_lexicon_not_found_exception::de_lexicon_not_found_exception_json_err(_response_body, output)
                     .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "MarksNotSupportedForFormatException" => crate::operation::synthesize_speech::SynthesizeSpeechError::MarksNotSupportedForFormatException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::MarksNotSupportedForFormatExceptionBuilder::default();
                 output = crate::protocol_serde::shape_marks_not_supported_for_format_exception::de_marks_not_supported_for_format_exception_json_err(
                     _response_body,
                     output,
--
+                )
                 .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ServiceFailureException" => crate::operation::synthesize_speech::SynthesizeSpeechError::ServiceFailureException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ServiceFailureExceptionBuilder::default();
                 output = crate::protocol_serde::shape_service_failure_exception::de_service_failure_exception_json_err(_response_body, output)
                     .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "SsmlMarksNotSupportedForTextTypeException" => {
             crate::operation::synthesize_speech::SynthesizeSpeechError::SsmlMarksNotSupportedForTextTypeException({
                 #[allow(unused_mut)]
                 let mut tmp = {
                     #[allow(unused_mut)]
                     let mut output = crate::types::error::builders::SsmlMarksNotSupportedForTextTypeExceptionBuilder::default();
                     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)?;
                     let output = output.meta(generic);
                     output.build()
                 };
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
--
+                }
                 tmp
             })
--
+        }
         "TextLengthExceededException" => crate::operation::synthesize_speech::SynthesizeSpeechError::TextLengthExceededException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::TextLengthExceededExceptionBuilder::default();
                 output =
                     crate::protocol_serde::shape_text_length_exceeded_exception::de_text_length_exceeded_exception_json_err(_response_body, output)
                         .map_err(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::synthesize_speech::SynthesizeSpeechError::generic(generic),
     })
--
+}
--
 pub fn ser_synthesize_speech_input(
     input: &crate::operation::synthesize_speech::SynthesizeSpeechInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_synthesize_speech_input::ser_synthesize_speech_input_input(&mut object, input)?;
     object.finish();
     Ok(::aws_smithy_types::body::SdkBody::from(out))
--
+}

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

@@ -1,0 +46,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub fn ser_synthesize_speech_input_input(
     object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
     input: &crate::operation::synthesize_speech::SynthesizeSpeechInput,
 ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
     if let Some(var_1) = &input.engine {
         object.key("Engine").string(var_1.as_str());
--
+    }
     if let Some(var_2) = &input.language_code {
         object.key("LanguageCode").string(var_2.as_str());
--
+    }
     if let Some(var_3) = &input.lexicon_names {
         let mut array_4 = object.key("LexiconNames").start_array();
         for item_5 in var_3 {
--
+            {
                 array_4.value().string(item_5.as_str());
--
+            }
--
+        }
         array_4.finish();
--
+    }
     if let Some(var_6) = &input.output_format {
         object.key("OutputFormat").string(var_6.as_str());
--
+    }
     if let Some(var_7) = &input.sample_rate {
         object.key("SampleRate").string(var_7.as_str());
--
+    }
     if let Some(var_8) = &input.speech_mark_types {
         let mut array_9 = object.key("SpeechMarkTypes").start_array();
         for item_10 in var_8 {
--
+            {
                 array_9.value().string(item_10.as_str());
--
+            }
--
+        }
         array_9.finish();
--
+    }
     if let Some(var_11) = &input.text {
         object.key("Text").string(var_11.as_str());
--
+    }
     if let Some(var_12) = &input.text_type {
         object.key("TextType").string(var_12.as_str());
--
+    }
     if let Some(var_13) = &input.voice_id {
         object.key("VoiceId").string(var_13.as_str());
--
+    }
     Ok(())
--
+}

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

@@ -1,0 +36,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_text_length_exceeded_exception_json_err(
     _value: &[u8],
     mut builder: crate::types::error::builders::TextLengthExceededExceptionBuilder,
 ) -> ::std::result::Result<crate::types::error::builders::TextLengthExceededExceptionBuilder, ::aws_smithy_json::deserialize::error::DeserializeError>
--
+{
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "message" => {
                     builder = builder.set_message(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

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

@@ -1,0 +38,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_unsupported_pls_alphabet_exception_json_err(
     _value: &[u8],
     mut builder: crate::types::error::builders::UnsupportedPlsAlphabetExceptionBuilder,
 ) -> ::std::result::Result<
     crate::types::error::builders::UnsupportedPlsAlphabetExceptionBuilder,
     ::aws_smithy_json::deserialize::error::DeserializeError,
 > {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "message" => {
                     builder = builder.set_message(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

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

@@ -1,0 +38,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_unsupported_pls_language_exception_json_err(
     _value: &[u8],
     mut builder: crate::types::error::builders::UnsupportedPlsLanguageExceptionBuilder,
 ) -> ::std::result::Result<
     crate::types::error::builders::UnsupportedPlsLanguageExceptionBuilder,
     ::aws_smithy_json::deserialize::error::DeserializeError,
 > {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "message" => {
                     builder = builder.set_message(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

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

@@ -1,0 +76,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_voice<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
     _value: &'a [u8],
 ) -> ::std::result::Result<Option<crate::types::Voice>, ::aws_smithy_json::deserialize::error::DeserializeError>
 where
     I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>,
--
+{
     match tokens.next().transpose()? {
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
             #[allow(unused_mut)]
             let mut builder = crate::types::builders::VoiceBuilder::default();
             loop {
                 match tokens.next().transpose()? {
                     Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
                     Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                         "Gender" => {
                             builder = builder.set_gender(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| crate::types::Gender::from(u.as_ref())))
                                     .transpose()?,
                             );
--
+                        }
                         "Id" => {
                             builder = builder.set_id(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| crate::types::VoiceId::from(u.as_ref())))
                                     .transpose()?,
                             );
--
+                        }
                         "LanguageCode" => {
                             builder = builder.set_language_code(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| crate::types::LanguageCode::from(u.as_ref())))
                                     .transpose()?,
                             );
--
+                        }
                         "LanguageName" => {
                             builder = builder.set_language_name(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                     .transpose()?,
                             );
--
+                        }
                         "Name" => {
                             builder = builder.set_name(
                                 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                                     .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                     .transpose()?,
                             );
--
+                        }
                         "AdditionalLanguageCodes" => {
                             builder = builder.set_additional_language_codes(crate::protocol_serde::shape_language_code_list::de_language_code_list(
                                 tokens, _value,
                             )?);
--
+                        }
                         "SupportedEngines" => {
                             builder = builder.set_supported_engines(crate::protocol_serde::shape_engine_list::de_engine_list(tokens, _value)?);
--
+                        }
                         _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
                     },
                     other => {
                         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                             "expected object key or end object, found: {other:?}"
                         )))
--
+                    }
--
+                }
--
+            }
             Ok(Some(builder.build()))
--
+        }
         _ => Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "expected start object or null",
         )),
--
+    }
--
+}

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

@@ -1,0 +37,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_voice_list<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
     _value: &'a [u8],
 ) -> ::std::result::Result<Option<::std::vec::Vec<crate::types::Voice>>, ::aws_smithy_json::deserialize::error::DeserializeError>
 where
     I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>,
--
+{
     match tokens.next().transpose()? {
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
             let mut items = Vec::new();
             loop {
                 match tokens.peek() {
                     Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
                         tokens.next().transpose().unwrap();
                         break;
--
+                    }
                     _ => {
                         let value = crate::protocol_serde::shape_voice::de_voice(tokens, _value)?;
                         if let Some(value) = value {
                             items.push(value);
                         } else {
                             return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                 "dense list cannot contain null values",
                             ));
--
+                        }
--
+                    }
--
+                }
--
+            }
             Ok(Some(items))
--
+        }
         _ => Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "expected start array or null",
         )),
--
+    }
--
+}

tmp-codegen-diff/aws-sdk/sdk/polly/src/types/_lexicon.rs

@@ -5,5 +126,137 @@

↥ Expand context

 #[derive(::std::clone::Clone, ::std::cmp::PartialEq)]
 pub struct Lexicon {
     /// <p>Lexicon content in string format. The content of a lexicon must be in PLS format.</p>
     pub content: ::std::option::Option<::std::string::String>,
     /// <p>Name of the lexicon.</p>
     pub name: ::std::option::Option<::std::string::String>,
-11
+}
 impl Lexicon {
     /// <p>Lexicon content in string format. The content of a lexicon must be in PLS format.</p>
     pub fn content(&self) -> ::std::option::Option<&str> {
         self.content.as_deref()
-16
+    }
     /// <p>Name of the lexicon.</p>
     pub fn name(&self) -> ::std::option::Option<&str> {
         self.name.as_deref()
-20
+    }
-21
+}
 impl ::std::fmt::Debug for Lexicon {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("Lexicon");

         formatter.field("content", &"*** Sensitive Data Redacted ***");
         formatter.field("name", &self.name);
         formatter.finish()
-28
+    }
-29
+}
 static LEXICON_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#Lexicon", "com.amazonaws.polly", "Lexicon");
 static LEXICON_MEMBER_CONTENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#Lexicon$Content", "com.amazonaws.polly", "Lexicon"),
     ::aws_smithy_schema::ShapeType::String,
     "content",
     "Content",
 ,
 );
 static LEXICON_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#Lexicon$Name", "com.amazonaws.polly", "Lexicon"),
     ::aws_smithy_schema::ShapeType::String,
     "name",
     "Name",
 ,
 );
 static LEXICON_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LEXICON_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&LEXICON_MEMBER_CONTENT, &LEXICON_MEMBER_NAME],
 );
 impl Lexicon {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LEXICON_SCHEMA;
-52
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Lexicon {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.content {
             ser.write_string(&LEXICON_MEMBER_CONTENT, val)?;
-61
+        }
         if let Some(ref val) = self.name {
             ser.write_string(&LEXICON_MEMBER_NAME, val)?;
-64
+        }
         Ok(())
-66
+    }
-67
+}
 impl Lexicon {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&LEXICON_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LEXICON_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.content = Some(deser.read_string(member)?);
-86
+                }
                 Some(1) => {
                     builder.name = Some(deser.read_string(member)?);
-89
+                }
                 _ => {}
-91
+            }
             Ok(())
         })?;
         Ok(builder.build())
-95
+    }
-96
+}
 impl Lexicon {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl Lexicon {
     /// Creates a new builder-style object to manufacture [`Lexicon`](crate::types::Lexicon).
     pub fn builder() -> crate::types::builders::LexiconBuilder {
         crate::types::builders::LexiconBuilder::default()
-112
+    }
-113
+}
-114
 /// A builder for [`Lexicon`](crate::types::Lexicon).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct LexiconBuilder {
     pub(crate) content: ::std::option::Option<::std::string::String>,
     pub(crate) name: ::std::option::Option<::std::string::String>,
-121
+}
 impl LexiconBuilder {
     /// <p>Lexicon content in string format. The content of a lexicon must be in PLS format.</p>
     pub fn content(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.content = ::std::option::Option::Some(input.into());
         self
-127
+    }
     /// <p>Lexicon content in string format. The content of a lexicon must be in PLS format.</p>
     pub fn set_content(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.content = input;
         self
-132
+    }
     /// <p>Lexicon content in string format. The content of a lexicon must be in PLS format.</p>
     pub fn get_content(&self) -> &::std::option::Option<::std::string::String> {
         &self.content
-136
+    }
     /// <p>Name of the lexicon.</p>

tmp-codegen-diff/aws-sdk/sdk/polly/src/types/_lexicon_attributes.rs

@@ -25,25 +219,230 @@

↥ Expand context

     /// <p>Language code that the lexicon applies to. A lexicon with a language code such as "en" would be applied to all English languages (en-GB, en-US, en-AUS, en-WLS, and so on.</p>
     pub fn language_code(&self) -> ::std::option::Option<&crate::types::LanguageCode> {
         self.language_code.as_ref()
-28
+    }
     /// <p>Date lexicon was last modified (a timestamp value).</p>
     pub fn last_modified(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.last_modified.as_ref()
-32
+    }
     /// <p>Amazon Resource Name (ARN) of the lexicon.</p>
     pub fn lexicon_arn(&self) -> ::std::option::Option<&str> {
         self.lexicon_arn.as_deref()
-36
+    }
     /// <p>Number of lexemes in the lexicon.</p>
     pub fn lexemes_count(&self) -> i32 {
         self.lexemes_count
-40
+    }
     /// <p>Total size of the lexicon, in characters.</p>
     pub fn size(&self) -> i32 {
         self.size
-44
+    }

-45
+}
 static LEXICONATTRIBUTES_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#LexiconAttributes", "com.amazonaws.polly", "LexiconAttributes");
 static LEXICONATTRIBUTES_MEMBER_ALPHABET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly#LexiconAttributes$Alphabet",
         "com.amazonaws.polly",
         "LexiconAttributes",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "alphabet",
     "Alphabet",
 ,
 );
 static LEXICONATTRIBUTES_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly#LexiconAttributes$LanguageCode",
         "com.amazonaws.polly",
         "LexiconAttributes",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_code",
     "LanguageCode",
 ,
 );
 static LEXICONATTRIBUTES_MEMBER_LAST_MODIFIED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly#LexiconAttributes$LastModified",
         "com.amazonaws.polly",
         "LexiconAttributes",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "last_modified",
     "LastModified",
 ,
 );
 static LEXICONATTRIBUTES_MEMBER_LEXICON_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly#LexiconAttributes$LexiconArn",
         "com.amazonaws.polly",
         "LexiconAttributes",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "lexicon_arn",
     "LexiconArn",
 ,
 );
 static LEXICONATTRIBUTES_MEMBER_LEXEMES_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly#LexiconAttributes$LexemesCount",
         "com.amazonaws.polly",
         "LexiconAttributes",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "lexemes_count",
     "LexemesCount",
 ,
 );
 static LEXICONATTRIBUTES_MEMBER_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#LexiconAttributes$Size", "com.amazonaws.polly", "LexiconAttributes"),
     ::aws_smithy_schema::ShapeType::Integer,
     "size",
     "Size",
 ,
 );
 static LEXICONATTRIBUTES_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LEXICONATTRIBUTES_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LEXICONATTRIBUTES_MEMBER_ALPHABET,
         &LEXICONATTRIBUTES_MEMBER_LANGUAGE_CODE,
         &LEXICONATTRIBUTES_MEMBER_LAST_MODIFIED,
         &LEXICONATTRIBUTES_MEMBER_LEXICON_ARN,
         &LEXICONATTRIBUTES_MEMBER_LEXEMES_COUNT,
         &LEXICONATTRIBUTES_MEMBER_SIZE,
     ],
 );
 impl LexiconAttributes {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LEXICONATTRIBUTES_SCHEMA;
-119
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LexiconAttributes {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.alphabet {
             ser.write_string(&LEXICONATTRIBUTES_MEMBER_ALPHABET, val)?;
-128
+        }
         if let Some(ref val) = self.language_code {
             ser.write_string(&LEXICONATTRIBUTES_MEMBER_LANGUAGE_CODE, val.as_str())?;
-131
+        }
         if let Some(ref val) = self.last_modified {
             ser.write_timestamp(&LEXICONATTRIBUTES_MEMBER_LAST_MODIFIED, val)?;
-134
+        }
         if let Some(ref val) = self.lexicon_arn {
             ser.write_string(&LEXICONATTRIBUTES_MEMBER_LEXICON_ARN, val)?;
-137
+        }
-138
+        {
             let val = &self.lexemes_count;
             ser.write_integer(&LEXICONATTRIBUTES_MEMBER_LEXEMES_COUNT, *val)?;
-141
+        }
-142
+        {
             let val = &self.size;
             ser.write_integer(&LEXICONATTRIBUTES_MEMBER_SIZE, *val)?;
-145
+        }
         Ok(())
-147
+    }
-148
+}
 impl LexiconAttributes {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&LEXICONATTRIBUTES_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LEXICONATTRIBUTES_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.alphabet = Some(deser.read_string(member)?);
-167
+                }
                 Some(1) => {
                     builder.language_code = Some(crate::types::LanguageCode::from(deser.read_string(member)?.as_str()));
-170
+                }
                 Some(2) => {
                     builder.last_modified = Some(deser.read_timestamp(member)?);
-173
+                }
                 Some(3) => {
                     builder.lexicon_arn = Some(deser.read_string(member)?);
-176
+                }
                 Some(4) => {
                     builder.lexemes_count = Some(deser.read_integer(member)?);
-179
+                }
                 Some(5) => {
                     builder.size = Some(deser.read_integer(member)?);
-182
+                }
                 _ => {}
-184
+            }
             Ok(())
         })?;
         Ok(builder.build())
-188
+    }
-189
+}
 impl LexiconAttributes {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl LexiconAttributes {
     /// Creates a new builder-style object to manufacture [`LexiconAttributes`](crate::types::LexiconAttributes).
     pub fn builder() -> crate::types::builders::LexiconAttributesBuilder {
         crate::types::builders::LexiconAttributesBuilder::default()
-205
+    }
-206
+}
-207
 /// A builder for [`LexiconAttributes`](crate::types::LexiconAttributes).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LexiconAttributesBuilder {
     pub(crate) alphabet: ::std::option::Option<::std::string::String>,
     pub(crate) language_code: ::std::option::Option<crate::types::LanguageCode>,
     pub(crate) last_modified: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) lexicon_arn: ::std::option::Option<::std::string::String>,
     pub(crate) lexemes_count: ::std::option::Option<i32>,
     pub(crate) size: ::std::option::Option<i32>,
-218
+}
 impl LexiconAttributesBuilder {
     /// <p>Phonetic alphabet used in the lexicon. Valid values are <code>ipa</code> and <code>x-sampa</code>.</p>
     pub fn alphabet(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.alphabet = ::std::option::Option::Some(input.into());
         self
-224
+    }
     /// <p>Phonetic alphabet used in the lexicon. Valid values are <code>ipa</code> and <code>x-sampa</code>.</p>
     pub fn set_alphabet(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.alphabet = input;
         self
-229
+    }
     /// <p>Phonetic alphabet used in the lexicon. Valid values are <code>ipa</code> and <code>x-sampa</code>.</p>

tmp-codegen-diff/aws-sdk/sdk/polly/src/types/_lexicon_description.rs

@@ -1,1 +122,133 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Describes the content of the lexicon.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct LexiconDescription {
     /// <p>Name of the lexicon.</p>
     pub name: ::std::option::Option<::std::string::String>,
     /// <p>Provides lexicon metadata.</p>
     pub attributes: ::std::option::Option<crate::types::LexiconAttributes>,
-11
+}
 impl LexiconDescription {
     /// <p>Name of the lexicon.</p>
     pub fn name(&self) -> ::std::option::Option<&str> {
         self.name.as_deref()
-16
+    }

     /// <p>Provides lexicon metadata.</p>
     pub fn attributes(&self) -> ::std::option::Option<&crate::types::LexiconAttributes> {
         self.attributes.as_ref()
-20
+    }
-21
+}
 static LEXICONDESCRIPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#LexiconDescription", "com.amazonaws.polly", "LexiconDescription");
 static LEXICONDESCRIPTION_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#LexiconDescription$Name", "com.amazonaws.polly", "LexiconDescription"),
     ::aws_smithy_schema::ShapeType::String,
     "name",
     "Name",
 ,
 );
 static LEXICONDESCRIPTION_MEMBER_ATTRIBUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly#LexiconDescription$Attributes",
         "com.amazonaws.polly",
         "LexiconDescription",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "attributes",
     "Attributes",
 ,
 );
 static LEXICONDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LEXICONDESCRIPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&LEXICONDESCRIPTION_MEMBER_NAME, &LEXICONDESCRIPTION_MEMBER_ATTRIBUTES],
 );
 impl LexiconDescription {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LEXICONDESCRIPTION_SCHEMA;
-48
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LexiconDescription {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.name {
             ser.write_string(&LEXICONDESCRIPTION_MEMBER_NAME, val)?;
-57
+        }
         if let Some(ref val) = self.attributes {
             ser.write_struct(&LEXICONDESCRIPTION_MEMBER_ATTRIBUTES, val)?;
-60
+        }
         Ok(())
-62
+    }
-63
+}
 impl LexiconDescription {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&LEXICONDESCRIPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LEXICONDESCRIPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.name = Some(deser.read_string(member)?);
-82
+                }
                 Some(1) => {
                     builder.attributes = Some(crate::types::LexiconAttributes::deserialize(deser)?);
-85
+                }
                 _ => {}
-87
+            }
             Ok(())
         })?;
         Ok(builder.build())
-91
+    }
-92
+}
 impl LexiconDescription {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl LexiconDescription {
     /// Creates a new builder-style object to manufacture [`LexiconDescription`](crate::types::LexiconDescription).
     pub fn builder() -> crate::types::builders::LexiconDescriptionBuilder {
         crate::types::builders::LexiconDescriptionBuilder::default()
-108
+    }
-109
+}
-110
 /// A builder for [`LexiconDescription`](crate::types::LexiconDescription).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LexiconDescriptionBuilder {
     pub(crate) name: ::std::option::Option<::std::string::String>,
     pub(crate) attributes: ::std::option::Option<crate::types::LexiconAttributes>,
-117
+}
 impl LexiconDescriptionBuilder {
     /// <p>Name of the lexicon.</p>
     pub fn name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.name = ::std::option::Option::Some(input.into());
         self
-123
+    }
     /// <p>Name of the lexicon.</p>
     pub fn set_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.name = input;
         self
-128
+    }
     /// <p>Name of the lexicon.</p>
     pub fn get_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.name
-132
+    }
     /// <p>Provides lexicon metadata.</p>

tmp-codegen-diff/aws-sdk/sdk/polly/src/types/_synthesis_task.rs

@@ -85,85 +241,241 @@

↥ Expand context

     /// <p>The valid values for mp3 and ogg_vorbis are "8000", "16000", "22050", and "24000". The default value for standard voices is "22050". The default value for neural voices is "24000". The default value for long-form voices is "24000". The default value for generative voices is "24000".</p>
     /// <p>Valid values for pcm are "8000" and "16000" The default value is "16000".</p>
     pub fn sample_rate(&self) -> ::std::option::Option<&str> {
         self.sample_rate.as_deref()
-89
+    }
     /// <p>The type of speech marks returned for the input text.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.speech_mark_types.is_none()`.
     pub fn speech_mark_types(&self) -> &[crate::types::SpeechMarkType] {
         self.speech_mark_types.as_deref().unwrap_or_default()
-95
+    }
     /// <p>Specifies whether the input text is plain text or SSML. The default value is plain text.</p>
     pub fn text_type(&self) -> ::std::option::Option<&crate::types::TextType> {
         self.text_type.as_ref()
-99
+    }
     /// <p>Voice ID to use for the synthesis.</p>
     pub fn voice_id(&self) -> ::std::option::Option<&crate::types::VoiceId> {
         self.voice_id.as_ref()
-103
+    }
     /// <p>Optional language code for a synthesis task. This is only necessary if using a bilingual voice, such as Aditi, which can be used for either Indian English (en-IN) or Hindi (hi-IN).</p>

     /// <p>If a bilingual voice is used and no language code is specified, Amazon Polly uses the default language of the bilingual voice. The default language for any voice is the one returned by the <a href="https://docs.aws.amazon.com/polly/latest/dg/API_DescribeVoices.html">DescribeVoices</a> operation for the <code>LanguageCode</code> parameter. For example, if no language code is specified, Aditi will use Indian English rather than Hindi.</p>
     pub fn language_code(&self) -> ::std::option::Option<&crate::types::LanguageCode> {
         self.language_code.as_ref()
-108
+    }
-109
+}
 static SYNTHESISTASK_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#SynthesisTask", "com.amazonaws.polly", "SynthesisTask");
 static SYNTHESISTASK_MEMBER_ENGINE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#SynthesisTask$Engine", "com.amazonaws.polly", "SynthesisTask"),
     ::aws_smithy_schema::ShapeType::String,
     "engine",
     "Engine",
 ,
 );
 static SYNTHESISTASK_MEMBER_TASK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#SynthesisTask$TaskId", "com.amazonaws.polly", "SynthesisTask"),
     ::aws_smithy_schema::ShapeType::String,
     "task_id",
     "TaskId",
 ,
 );
 static SYNTHESISTASK_MEMBER_TASK_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#SynthesisTask$TaskStatus", "com.amazonaws.polly", "SynthesisTask"),
     ::aws_smithy_schema::ShapeType::String,
     "task_status",
     "TaskStatus",
 ,
 );
 static SYNTHESISTASK_MEMBER_TASK_STATUS_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly#SynthesisTask$TaskStatusReason",
         "com.amazonaws.polly",
         "SynthesisTask",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "task_status_reason",
     "TaskStatusReason",
 ,
 );
 static SYNTHESISTASK_MEMBER_OUTPUT_URI: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#SynthesisTask$OutputUri", "com.amazonaws.polly", "SynthesisTask"),
     ::aws_smithy_schema::ShapeType::String,
     "output_uri",
     "OutputUri",
 ,
 );
 static SYNTHESISTASK_MEMBER_CREATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#SynthesisTask$CreationTime", "com.amazonaws.polly", "SynthesisTask"),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "creation_time",
     "CreationTime",
 ,
 );
 static SYNTHESISTASK_MEMBER_REQUEST_CHARACTERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly#SynthesisTask$RequestCharacters",
         "com.amazonaws.polly",
         "SynthesisTask",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "request_characters",
     "RequestCharacters",
 ,
 );
 static SYNTHESISTASK_MEMBER_SNS_TOPIC_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#SynthesisTask$SnsTopicArn", "com.amazonaws.polly", "SynthesisTask"),
     ::aws_smithy_schema::ShapeType::String,
     "sns_topic_arn",
     "SnsTopicArn",
 ,
 );
 static SYNTHESISTASK_MEMBER_LEXICON_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#SynthesisTask$LexiconNames", "com.amazonaws.polly", "SynthesisTask"),
     ::aws_smithy_schema::ShapeType::List,
     "lexicon_names",
     "LexiconNames",
 ,
 );
 static SYNTHESISTASK_MEMBER_OUTPUT_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#SynthesisTask$OutputFormat", "com.amazonaws.polly", "SynthesisTask"),
     ::aws_smithy_schema::ShapeType::String,
     "output_format",
     "OutputFormat",
 ,
 );
 static SYNTHESISTASK_MEMBER_SAMPLE_RATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#SynthesisTask$SampleRate", "com.amazonaws.polly", "SynthesisTask"),
     ::aws_smithy_schema::ShapeType::String,
     "sample_rate",
     "SampleRate",
 ,
 );
 static SYNTHESISTASK_MEMBER_SPEECH_MARK_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly#SynthesisTask$SpeechMarkTypes",
         "com.amazonaws.polly",
         "SynthesisTask",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "speech_mark_types",
     "SpeechMarkTypes",
 ,
 );
 static SYNTHESISTASK_MEMBER_TEXT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#SynthesisTask$TextType", "com.amazonaws.polly", "SynthesisTask"),
     ::aws_smithy_schema::ShapeType::String,
     "text_type",
     "TextType",
 ,
 );
 static SYNTHESISTASK_MEMBER_VOICE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#SynthesisTask$VoiceId", "com.amazonaws.polly", "SynthesisTask"),
     ::aws_smithy_schema::ShapeType::String,
     "voice_id",
     "VoiceId",
 ,
 );
 static SYNTHESISTASK_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#SynthesisTask$LanguageCode", "com.amazonaws.polly", "SynthesisTask"),
     ::aws_smithy_schema::ShapeType::String,
     "language_code",
     "LanguageCode",
 ,
 );
 static SYNTHESISTASK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SYNTHESISTASK_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SYNTHESISTASK_MEMBER_ENGINE,
         &SYNTHESISTASK_MEMBER_TASK_ID,
         &SYNTHESISTASK_MEMBER_TASK_STATUS,
         &SYNTHESISTASK_MEMBER_TASK_STATUS_REASON,

↧ Expand context

         &SYNTHESISTASK_MEMBER_OUTPUT_URI,
         &SYNTHESISTASK_MEMBER_CREATION_TIME,
         &SYNTHESISTASK_MEMBER_REQUEST_CHARACTERS,
         &SYNTHESISTASK_MEMBER_SNS_TOPIC_ARN,
         &SYNTHESISTASK_MEMBER_LEXICON_NAMES,
         &SYNTHESISTASK_MEMBER_OUTPUT_FORMAT,
         &SYNTHESISTASK_MEMBER_SAMPLE_RATE,
         &SYNTHESISTASK_MEMBER_SPEECH_MARK_TYPES,
         &SYNTHESISTASK_MEMBER_TEXT_TYPE,
         &SYNTHESISTASK_MEMBER_VOICE_ID,
         &SYNTHESISTASK_MEMBER_LANGUAGE_CODE,
     ],
 );
 impl SynthesisTask {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SYNTHESISTASK_SCHEMA;
-238
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SynthesisTask {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(

@@ -282,282 +427,425 @@

↥ Expand context

             ser.write_string(&SYNTHESISTASK_MEMBER_OUTPUT_FORMAT, val.as_str())?;
-283
+        }
         if let Some(ref val) = self.sample_rate {
             ser.write_string(&SYNTHESISTASK_MEMBER_SAMPLE_RATE, val)?;
-286
+        }
         if let Some(ref val) = self.speech_mark_types {
             ser.write_list(
                 &SYNTHESISTASK_MEMBER_SPEECH_MARK_TYPES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
-293
+                    }
                     Ok(())
                 },
             )?;
-297
+        }
         if let Some(ref val) = self.text_type {
             ser.write_string(&SYNTHESISTASK_MEMBER_TEXT_TYPE, val.as_str())?;
-300
+        }
         if let Some(ref val) = self.voice_id {

             ser.write_string(&SYNTHESISTASK_MEMBER_VOICE_ID, val.as_str())?;
-303
+        }
         if let Some(ref val) = self.language_code {
             ser.write_string(&SYNTHESISTASK_MEMBER_LANGUAGE_CODE, val.as_str())?;
-306
+        }
         Ok(())
-308
+    }
-309
+}
 impl SynthesisTask {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&SYNTHESISTASK_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SYNTHESISTASK_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.engine = Some(crate::types::Engine::from(deser.read_string(member)?.as_str()));
-328
+                }
                 Some(1) => {
                     builder.task_id = Some(deser.read_string(member)?);
-331
+                }
                 Some(2) => {
                     builder.task_status = Some(crate::types::TaskStatus::from(deser.read_string(member)?.as_str()));
-334
+                }
                 Some(3) => {
                     builder.task_status_reason = Some(deser.read_string(member)?);
-337
+                }
                 Some(4) => {
                     builder.output_uri = Some(deser.read_string(member)?);
-340
+                }
                 Some(5) => {
                     builder.creation_time = Some(deser.read_timestamp(member)?);
-343
+                }
                 Some(6) => {
                     builder.request_characters = Some(deser.read_integer(member)?);
-346
+                }
                 Some(7) => {
                     builder.sns_topic_arn = Some(deser.read_string(member)?);
-349
+                }
                 Some(8) => {
                     builder.lexicon_names = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.lexicon_names = Some(deser.read_string_list(member)?);
-352
+                }
                 Some(9) => {
                     builder.output_format = Some(crate::types::OutputFormat::from(deser.read_string(member)?.as_str()));
-355
+                }
                 Some(10) => {
                     builder.sample_rate = Some(deser.read_string(member)?);
-358
+                }
                 Some(11) => {
                     builder.speech_mark_types = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::SpeechMarkType::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::SpeechMarkType::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-368
+                }
                 Some(12) => {
                     builder.text_type = Some(crate::types::TextType::from(deser.read_string(member)?.as_str()));
-371
+                }
                 Some(13) => {
                     builder.voice_id = Some(crate::types::VoiceId::from(deser.read_string(member)?.as_str()));
-374
+                }
                 Some(14) => {
                     builder.language_code = Some(crate::types::LanguageCode::from(deser.read_string(member)?.as_str()));
-377
+                }
                 _ => {}
-379
+            }
             Ok(())
         })?;
         Ok(builder.build())
-383
+    }
-384
+}
 impl SynthesisTask {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl SynthesisTask {
     /// Creates a new builder-style object to manufacture [`SynthesisTask`](crate::types::SynthesisTask).
     pub fn builder() -> crate::types::builders::SynthesisTaskBuilder {
         crate::types::builders::SynthesisTaskBuilder::default()
-400
+    }
-401
+}
-402
 /// A builder for [`SynthesisTask`](crate::types::SynthesisTask).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SynthesisTaskBuilder {
     pub(crate) engine: ::std::option::Option<crate::types::Engine>,
     pub(crate) task_id: ::std::option::Option<::std::string::String>,
     pub(crate) task_status: ::std::option::Option<crate::types::TaskStatus>,
     pub(crate) task_status_reason: ::std::option::Option<::std::string::String>,
     pub(crate) output_uri: ::std::option::Option<::std::string::String>,
     pub(crate) creation_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) request_characters: ::std::option::Option<i32>,
     pub(crate) sns_topic_arn: ::std::option::Option<::std::string::String>,
     pub(crate) lexicon_names: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) output_format: ::std::option::Option<crate::types::OutputFormat>,
     pub(crate) sample_rate: ::std::option::Option<::std::string::String>,
     pub(crate) speech_mark_types: ::std::option::Option<::std::vec::Vec<crate::types::SpeechMarkType>>,
     pub(crate) text_type: ::std::option::Option<crate::types::TextType>,
     pub(crate) voice_id: ::std::option::Option<crate::types::VoiceId>,
     pub(crate) language_code: ::std::option::Option<crate::types::LanguageCode>,
-422
+}
 impl SynthesisTaskBuilder {
     /// <p>Specifies the engine (<code>standard</code>, <code>neural</code>, <code>long-form</code> or <code>generative</code>) for Amazon Polly to use when processing input text for speech synthesis. Using a voice that is not supported for the engine selected will result in an error.</p>
     pub fn engine(mut self, input: crate::types::Engine) -> Self {

tmp-codegen-diff/aws-sdk/sdk/polly/src/types/_voice.rs

@@ -33,33 +129,129 @@

↥ Expand context

     pub fn language_code(&self) -> ::std::option::Option<&crate::types::LanguageCode> {
         self.language_code.as_ref()
-35
+    }
     /// <p>Human readable name of the language in English.</p>
     pub fn language_name(&self) -> ::std::option::Option<&str> {
         self.language_name.as_deref()
-39
+    }
     /// <p>Name of the voice (for example, Salli, Kendra, etc.). This provides a human readable voice name that you might display in your application.</p>
     pub fn name(&self) -> ::std::option::Option<&str> {
         self.name.as_deref()
-43
+    }
     /// <p>Additional codes for languages available for the specified voice in addition to its default language.</p>
     /// <p>For example, the default language for Aditi is Indian English (en-IN) because it was first used for that language. Since Aditi is bilingual and fluent in both Indian English and Hindi, this parameter would show the code <code>hi-IN</code>.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.additional_language_codes.is_none()`.
     pub fn additional_language_codes(&self) -> &[crate::types::LanguageCode] {
         self.additional_language_codes.as_deref().unwrap_or_default()
-50
+    }
     /// <p>Specifies which engines (<code>standard</code>, <code>neural</code>, <code>long-form</code> or <code>generative</code>) are supported by a given voice.</p>
     ///

     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.supported_engines.is_none()`.
     pub fn supported_engines(&self) -> &[crate::types::Engine] {
         self.supported_engines.as_deref().unwrap_or_default()
-56
+    }
-57
+}
 static VOICE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#Voice", "com.amazonaws.polly", "Voice");
 static VOICE_MEMBER_GENDER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#Voice$Gender", "com.amazonaws.polly", "Voice"),
     ::aws_smithy_schema::ShapeType::String,
     "gender",
     "Gender",
 ,
 );
 static VOICE_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#Voice$Id", "com.amazonaws.polly", "Voice"),
     ::aws_smithy_schema::ShapeType::String,
     "id",
     "Id",
 ,
 );
 static VOICE_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#Voice$LanguageCode", "com.amazonaws.polly", "Voice"),
     ::aws_smithy_schema::ShapeType::String,
     "language_code",
     "LanguageCode",
 ,
 );
 static VOICE_MEMBER_LANGUAGE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#Voice$LanguageName", "com.amazonaws.polly", "Voice"),
     ::aws_smithy_schema::ShapeType::String,
     "language_name",
     "LanguageName",
 ,
 );
 static VOICE_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#Voice$Name", "com.amazonaws.polly", "Voice"),
     ::aws_smithy_schema::ShapeType::String,
     "name",
     "Name",
 ,
 );
 static VOICE_MEMBER_ADDITIONAL_LANGUAGE_CODES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#Voice$AdditionalLanguageCodes", "com.amazonaws.polly", "Voice"),
     ::aws_smithy_schema::ShapeType::List,
     "additional_language_codes",
     "AdditionalLanguageCodes",
 ,
 );
 static VOICE_MEMBER_SUPPORTED_ENGINES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.polly#Voice$SupportedEngines", "com.amazonaws.polly", "Voice"),
     ::aws_smithy_schema::ShapeType::List,
     "supported_engines",
     "SupportedEngines",
 ,
 );
 static VOICE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VOICE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VOICE_MEMBER_GENDER,
         &VOICE_MEMBER_ID,
         &VOICE_MEMBER_LANGUAGE_CODE,
         &VOICE_MEMBER_LANGUAGE_NAME,

↧ Expand context

         &VOICE_MEMBER_NAME,
         &VOICE_MEMBER_ADDITIONAL_LANGUAGE_CODES,
         &VOICE_MEMBER_SUPPORTED_ENGINES,
     ],
 );
 impl Voice {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VOICE_SCHEMA;
-118
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Voice {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.gender {
             ser.write_string(&VOICE_MEMBER_GENDER, val.as_str())?;
-127
+        }
         if let Some(ref val) = self.id {
             ser.write_string(&VOICE_MEMBER_ID, val.as_str())?;

@@ -137,137 +258,263 @@

↥ Expand context

         if let Some(ref val) = self.name {
             ser.write_string(&VOICE_MEMBER_NAME, val)?;
-139
+        }
         if let Some(ref val) = self.additional_language_codes {
             ser.write_list(
                 &VOICE_MEMBER_ADDITIONAL_LANGUAGE_CODES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
-146
+                    }
                     Ok(())
                 },
             )?;
-150
+        }
         if let Some(ref val) = self.supported_engines {
             ser.write_list(
                 &VOICE_MEMBER_SUPPORTED_ENGINES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;

-157
+                    }
                     Ok(())
                 },
             )?;
-161
+        }
         Ok(())
-163
+    }
-164
+}
 impl Voice {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&VOICE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VOICE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.gender = Some(crate::types::Gender::from(deser.read_string(member)?.as_str()));
-183
+                }
                 Some(1) => {
                     builder.id = Some(crate::types::VoiceId::from(deser.read_string(member)?.as_str()));
-186
+                }
                 Some(2) => {
                     builder.language_code = Some(crate::types::LanguageCode::from(deser.read_string(member)?.as_str()));
-189
+                }
                 Some(3) => {
                     builder.language_name = Some(deser.read_string(member)?);
-192
+                }
                 Some(4) => {
                     builder.name = Some(deser.read_string(member)?);
-195
+                }
                 Some(5) => {
                     builder.additional_language_codes = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::LanguageCode::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::LanguageCode::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-205
+                }
                 Some(6) => {
                     builder.supported_engines = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Engine::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Engine::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-215
+                }
                 _ => {}
-217
+            }
             Ok(())
         })?;
         Ok(builder.build())
-221
+    }
-222
+}
 impl Voice {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl Voice {
     /// Creates a new builder-style object to manufacture [`Voice`](crate::types::Voice).
     pub fn builder() -> crate::types::builders::VoiceBuilder {
         crate::types::builders::VoiceBuilder::default()
-238
+    }
-239
+}
-240
 /// A builder for [`Voice`](crate::types::Voice).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VoiceBuilder {
     pub(crate) gender: ::std::option::Option<crate::types::Gender>,
     pub(crate) id: ::std::option::Option<crate::types::VoiceId>,
     pub(crate) language_code: ::std::option::Option<crate::types::LanguageCode>,
     pub(crate) language_name: ::std::option::Option<::std::string::String>,
     pub(crate) name: ::std::option::Option<::std::string::String>,
     pub(crate) additional_language_codes: ::std::option::Option<::std::vec::Vec<crate::types::LanguageCode>>,
     pub(crate) supported_engines: ::std::option::Option<::std::vec::Vec<crate::types::Engine>>,
-252
+}
 impl VoiceBuilder {
     /// <p>Gender of the voice.</p>
     pub fn gender(mut self, input: crate::types::Gender) -> Self {
         self.gender = ::std::option::Option::Some(input);
         self
-258
+    }
     /// <p>Gender of the voice.</p>
     pub fn set_gender(mut self, input: ::std::option::Option<crate::types::Gender>) -> Self {
         self.gender = input;
         self
-263
+    }

AWS SDK

Files changed: