AWS SDK

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/start_speech_synthesis_task/_start_speech_synthesis_task_input.rs

@@ -73,73 +263,264 @@

     ///
     /// 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()
-77
+    }
     /// <p>The input text to synthesize. If you specify ssml as the TextType, follow the SSML format for the input text.</p>
     pub fn text(&self) -> ::std::option::Option<&str> {
         self.text.as_deref()
-81
+    }
     /// <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()
-85
+    }
     /// <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()
-89
+    }
-90
+}
 static STARTSPEECHSYNTHESISTASKINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskInput",

     "com.amazonaws.polly.synthetic",
     "StartSpeechSynthesisTaskInput",
 );
 static STARTSPEECHSYNTHESISTASKINPUT_MEMBER_ENGINE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskInput$Engine",
         "com.amazonaws.polly.synthetic",
         "StartSpeechSynthesisTaskInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "engine",
     "Engine",
 ,
 );
 static STARTSPEECHSYNTHESISTASKINPUT_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskInput$LanguageCode",
         "com.amazonaws.polly.synthetic",
         "StartSpeechSynthesisTaskInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_code",
     "LanguageCode",
 ,
 );
 static STARTSPEECHSYNTHESISTASKINPUT_MEMBER_LEXICON_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskInput$LexiconNames",
         "com.amazonaws.polly.synthetic",
         "StartSpeechSynthesisTaskInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "lexicon_names",
     "LexiconNames",
 ,
 );
 static STARTSPEECHSYNTHESISTASKINPUT_MEMBER_OUTPUT_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskInput$OutputFormat",
         "com.amazonaws.polly.synthetic",
         "StartSpeechSynthesisTaskInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "output_format",
     "OutputFormat",
 ,
 );
 static STARTSPEECHSYNTHESISTASKINPUT_MEMBER_OUTPUT_S3_BUCKET_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskInput$OutputS3BucketName",
         "com.amazonaws.polly.synthetic",
         "StartSpeechSynthesisTaskInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "output_s3_bucket_name",
     "OutputS3BucketName",
 ,
 );
 static STARTSPEECHSYNTHESISTASKINPUT_MEMBER_OUTPUT_S3_KEY_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskInput$OutputS3KeyPrefix",
         "com.amazonaws.polly.synthetic",
         "StartSpeechSynthesisTaskInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "output_s3_key_prefix",
     "OutputS3KeyPrefix",
 ,
 );
 static STARTSPEECHSYNTHESISTASKINPUT_MEMBER_SAMPLE_RATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskInput$SampleRate",
         "com.amazonaws.polly.synthetic",
         "StartSpeechSynthesisTaskInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sample_rate",
     "SampleRate",
 ,
 );
 static STARTSPEECHSYNTHESISTASKINPUT_MEMBER_SNS_TOPIC_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskInput$SnsTopicArn",
         "com.amazonaws.polly.synthetic",
         "StartSpeechSynthesisTaskInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sns_topic_arn",
     "SnsTopicArn",
 ,
 );
 static STARTSPEECHSYNTHESISTASKINPUT_MEMBER_SPEECH_MARK_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskInput$SpeechMarkTypes",
         "com.amazonaws.polly.synthetic",
         "StartSpeechSynthesisTaskInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "speech_mark_types",
     "SpeechMarkTypes",
 ,
 );
 static STARTSPEECHSYNTHESISTASKINPUT_MEMBER_TEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskInput$Text",
         "com.amazonaws.polly.synthetic",
         "StartSpeechSynthesisTaskInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "text",
     "Text",
 ,
 );
 static STARTSPEECHSYNTHESISTASKINPUT_MEMBER_TEXT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskInput$TextType",
         "com.amazonaws.polly.synthetic",
         "StartSpeechSynthesisTaskInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "text_type",
     "TextType",
 ,
 );
 static STARTSPEECHSYNTHESISTASKINPUT_MEMBER_VOICE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskInput$VoiceId",
         "com.amazonaws.polly.synthetic",
         "StartSpeechSynthesisTaskInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "voice_id",
     "VoiceId",
 ,
 );
 static STARTSPEECHSYNTHESISTASKINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTSPEECHSYNTHESISTASKINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STARTSPEECHSYNTHESISTASKINPUT_MEMBER_ENGINE,
         &STARTSPEECHSYNTHESISTASKINPUT_MEMBER_LANGUAGE_CODE,
         &STARTSPEECHSYNTHESISTASKINPUT_MEMBER_LEXICON_NAMES,
         &STARTSPEECHSYNTHESISTASKINPUT_MEMBER_OUTPUT_FORMAT,
         &STARTSPEECHSYNTHESISTASKINPUT_MEMBER_OUTPUT_S3_BUCKET_NAME,
         &STARTSPEECHSYNTHESISTASKINPUT_MEMBER_OUTPUT_S3_KEY_PREFIX,
         &STARTSPEECHSYNTHESISTASKINPUT_MEMBER_SAMPLE_RATE,
         &STARTSPEECHSYNTHESISTASKINPUT_MEMBER_SNS_TOPIC_ARN,
         &STARTSPEECHSYNTHESISTASKINPUT_MEMBER_SPEECH_MARK_TYPES,
         &STARTSPEECHSYNTHESISTASKINPUT_MEMBER_TEXT,
         &STARTSPEECHSYNTHESISTASKINPUT_MEMBER_TEXT_TYPE,
         &STARTSPEECHSYNTHESISTASKINPUT_MEMBER_VOICE_ID,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/v1/synthesisTasks", None));
 impl StartSpeechSynthesisTaskInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTSPEECHSYNTHESISTASKINPUT_SCHEMA;
-238
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartSpeechSynthesisTaskInput {
     #[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> {

↧ Expand context

         if let Some(ref val) = self.engine {
             ser.write_string(&STARTSPEECHSYNTHESISTASKINPUT_MEMBER_ENGINE, val.as_str())?;
-247
+        }
         if let Some(ref val) = self.language_code {
             ser.write_string(&STARTSPEECHSYNTHESISTASKINPUT_MEMBER_LANGUAGE_CODE, val.as_str())?;
-250
+        }
         if let Some(ref val) = self.lexicon_names {
             ser.write_list(
                 &STARTSPEECHSYNTHESISTASKINPUT_MEMBER_LEXICON_NAMES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-257
+                    }
                     Ok(())
                 },
             )?;
-261
+        }
         if let Some(ref val) = self.output_format {
             ser.write_string(&STARTSPEECHSYNTHESISTASKINPUT_MEMBER_OUTPUT_FORMAT, val.as_str())?;
-264
+        }

@@ -271,272 +409,410 @@

↥ Expand context

             ser.write_string(&STARTSPEECHSYNTHESISTASKINPUT_MEMBER_SAMPLE_RATE, val)?;
-273
+        }
         if let Some(ref val) = self.sns_topic_arn {
             ser.write_string(&STARTSPEECHSYNTHESISTASKINPUT_MEMBER_SNS_TOPIC_ARN, val)?;
-276
+        }
         if let Some(ref val) = self.speech_mark_types {
             ser.write_list(
                 &STARTSPEECHSYNTHESISTASKINPUT_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())?;
-283
+                    }
                     Ok(())
                 },
             )?;
-287
+        }
         if let Some(ref val) = self.text {
             ser.write_string(&STARTSPEECHSYNTHESISTASKINPUT_MEMBER_TEXT, val)?;
-290
+        }
         if let Some(ref val) = self.text_type {

             ser.write_string(&STARTSPEECHSYNTHESISTASKINPUT_MEMBER_TEXT_TYPE, val.as_str())?;
-293
+        }
         if let Some(ref val) = self.voice_id {
             ser.write_string(&STARTSPEECHSYNTHESISTASKINPUT_MEMBER_VOICE_ID, val.as_str())?;
-296
+        }
         Ok(())
-298
+    }
-299
+}
 impl StartSpeechSynthesisTaskInput {
     /// 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(&STARTSPEECHSYNTHESISTASKINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTSPEECHSYNTHESISTASKINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.engine = Some(crate::types::Engine::from(deser.read_string(member)?.as_str()));
-318
+                }
                 Some(1) => {
                     builder.language_code = Some(crate::types::LanguageCode::from(deser.read_string(member)?.as_str()));
-321
+                }
                 Some(2) => {
                     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)?);
-324
+                }
                 Some(3) => {
                     builder.output_format = Some(crate::types::OutputFormat::from(deser.read_string(member)?.as_str()));
-327
+                }
                 Some(4) => {
                     builder.output_s3_bucket_name = Some(deser.read_string(member)?);
-330
+                }
                 Some(5) => {
                     builder.output_s3_key_prefix = Some(deser.read_string(member)?);
-333
+                }
                 Some(6) => {
                     builder.sample_rate = Some(deser.read_string(member)?);
-336
+                }
                 Some(7) => {
                     builder.sns_topic_arn = Some(deser.read_string(member)?);
-339
+                }
                 Some(8) => {
                     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
                     });
-349
+                }
                 Some(9) => {
                     builder.text = Some(deser.read_string(member)?);
-352
+                }
                 Some(10) => {
                     builder.text_type = Some(crate::types::TextType::from(deser.read_string(member)?.as_str()));
-355
+                }
                 Some(11) => {
                     builder.voice_id = Some(crate::types::VoiceId::from(deser.read_string(member)?.as_str()));
-358
+                }
                 _ => {}
-360
+            }
             Ok(())
         })?;
         builder.output_s3_bucket_name = builder.output_s3_bucket_name.or(Some(String::new()));
         builder.text = builder.text.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-368
+    }
-369
+}
 impl StartSpeechSynthesisTaskInput {
     /// 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 StartSpeechSynthesisTaskInput {
     /// Creates a new builder-style object to manufacture [`StartSpeechSynthesisTaskInput`](crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskInput).
     pub fn builder() -> crate::operation::start_speech_synthesis_task::builders::StartSpeechSynthesisTaskInputBuilder {
         crate::operation::start_speech_synthesis_task::builders::StartSpeechSynthesisTaskInputBuilder::default()
-385
+    }
-386
+}
-387
 /// A builder for [`StartSpeechSynthesisTaskInput`](crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct StartSpeechSynthesisTaskInputBuilder {
     pub(crate) engine: ::std::option::Option<crate::types::Engine>,
     pub(crate) language_code: ::std::option::Option<crate::types::LanguageCode>,
     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) output_s3_bucket_name: ::std::option::Option<::std::string::String>,
     pub(crate) output_s3_key_prefix: ::std::option::Option<::std::string::String>,
     pub(crate) sample_rate: ::std::option::Option<::std::string::String>,
     pub(crate) sns_topic_arn: ::std::option::Option<::std::string::String>,
     pub(crate) speech_mark_types: ::std::option::Option<::std::vec::Vec<crate::types::SpeechMarkType>>,
     pub(crate) text: ::std::option::Option<::std::string::String>,
     pub(crate) text_type: ::std::option::Option<crate::types::TextType>,
     pub(crate) voice_id: ::std::option::Option<crate::types::VoiceId>,
-404
+}
 impl StartSpeechSynthesisTaskInputBuilder {
     /// <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 {
         self.engine = ::std::option::Option::Some(input);
         self
-410
+    }

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/start_speech_synthesis_task/_start_speech_synthesis_task_output.rs

@@ -1,1 +96,143 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct StartSpeechSynthesisTaskOutput {
     /// <p>SynthesisTask object that provides information and attributes about a newly submitted speech synthesis task.</p>
     pub synthesis_task: ::std::option::Option<crate::types::SynthesisTask>,
     _request_id: Option<String>,
-9
+}
 impl StartSpeechSynthesisTaskOutput {
     /// <p>SynthesisTask object that provides information and attributes about a newly submitted speech synthesis task.</p>
     pub fn synthesis_task(&self) -> ::std::option::Option<&crate::types::SynthesisTask> {
         self.synthesis_task.as_ref()
-14
+    }
-15
+}
 static STARTSPEECHSYNTHESISTASKOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskOutput",

     "com.amazonaws.polly.synthetic",
     "StartSpeechSynthesisTaskOutput",
 );
 static STARTSPEECHSYNTHESISTASKOUTPUT_MEMBER_SYNTHESIS_TASK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#StartSpeechSynthesisTaskOutput$SynthesisTask",
         "com.amazonaws.polly.synthetic",
         "StartSpeechSynthesisTaskOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "synthesis_task",
     "SynthesisTask",
 ,
 );
 static STARTSPEECHSYNTHESISTASKOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static STARTSPEECHSYNTHESISTASKOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTSPEECHSYNTHESISTASKOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&STARTSPEECHSYNTHESISTASKOUTPUT_MEMBER_SYNTHESIS_TASK],
     &[
         &STARTSPEECHSYNTHESISTASKOUTPUT_MEMBER_SYNTHESIS_TASK,
         &STARTSPEECHSYNTHESISTASKOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl StartSpeechSynthesisTaskOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTSPEECHSYNTHESISTASKOUTPUT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartSpeechSynthesisTaskOutput {
     #[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.synthesis_task {
             ser.write_struct(&STARTSPEECHSYNTHESISTASKOUTPUT_MEMBER_SYNTHESIS_TASK, val)?;
-58
+        }
         Ok(())
-60
+    }
-61
+}
 impl StartSpeechSynthesisTaskOutput {
     /// 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(&STARTSPEECHSYNTHESISTASKOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTSPEECHSYNTHESISTASKOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.synthesis_task = Some(crate::types::SynthesisTask::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl StartSpeechSynthesisTaskOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STARTSPEECHSYNTHESISTASKOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.synthesis_task = Some(crate::types::SynthesisTask::deserialize(deser)?);
-117
+                }
                 _ => {}
-119
+            }
             Ok(())
         })?;
         Ok(builder.build())
-123
+    }

↧ Expand context

-124
+}
 impl ::aws_types::request_id::RequestId for StartSpeechSynthesisTaskOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-128
+    }
-129
+}
 impl StartSpeechSynthesisTaskOutput {
     /// Creates a new builder-style object to manufacture [`StartSpeechSynthesisTaskOutput`](crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskOutput).
     pub fn builder() -> crate::operation::start_speech_synthesis_task::builders::StartSpeechSynthesisTaskOutputBuilder {
         crate::operation::start_speech_synthesis_task::builders::StartSpeechSynthesisTaskOutputBuilder::default()
-134
+    }
-135
+}
-136
 /// A builder for [`StartSpeechSynthesisTaskOutput`](crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartSpeechSynthesisTaskOutputBuilder {
     pub(crate) synthesis_task: ::std::option::Option<crate::types::SynthesisTask>,
     _request_id: Option<String>,
-143
+}

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/synthesize_speech.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `SynthesizeSpeech`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct SynthesizeSpeech;
 impl SynthesizeSpeech {
     /// Creates a new `SynthesizeSpeech`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::synthesize_speech::SynthesizeSpeechInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::synthesize_speech::SynthesizeSpeechOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::synthesize_speech::SynthesizeSpeechInput,
     ) -> ::std::result::Result<
         crate::operation::synthesize_speech::SynthesizeSpeechOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::synthesize_speech::SynthesizeSpeechError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::synthesize_speech::SynthesizeSpeechError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::synthesize_speech::SynthesizeSpeechOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -56,60 +116,242 @@

↥ Expand context

             // seven-digit ID for the operation orchestration so that it can be correlated in the logs.
             .instrument(::tracing::debug_span!(
                 "Polly.SynthesizeSpeech",
                 "rpc.service" = "Polly",
                 "rpc.method" = "SynthesizeSpeech",
                 "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),
                 "rpc.system" = "aws-api",
             ))
             .await
-69
+    }
-70
     pub(crate) fn operation_runtime_plugins(
         client_runtime_plugins: ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         client_config: &crate::config::Config,
         config_override: ::std::option::Option<crate::config::Builder>,
     ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
         let mut runtime_plugins = client_runtime_plugins.with_operation_plugin(Self::new());
-77
         if let ::std::option::Option::Some(config_override) = config_override {
             for plugin in config_override.runtime_plugins.iter().cloned() {

                 runtime_plugins = runtime_plugins.with_operation_plugin(plugin);
-81
+            }
             runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(
                 config_override,
                 client_config.config.clone(),
                 &client_config.runtime_components,
             ));
-87
+        }
         runtime_plugins
-89
+    }
     /// The schema for this operation's presigned input shape.
     pub const PRESIGNED_INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = &PRESIGNED_SCHEMA;
-92
+}
 static PRESIGNED_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.polly.synthetic.synthetic.aws.presigned#SynthesizeSpeechInput",
     "com.amazonaws.polly.synthetic.synthetic.aws.presigned",
     "SynthesizeSpeechInput",
 );
 static PRESIGNED_MEMBER_ENGINE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned#SynthesizeSpeechInput$Engine",
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "Engine",
 ,
-+
+)
 .with_http_query("Engine");
 static PRESIGNED_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned#SynthesizeSpeechInput$LanguageCode",
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "LanguageCode",
 ,
-+
+)
 .with_http_query("LanguageCode");
 static PRESIGNED_MEMBER_LEXICON_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned#SynthesizeSpeechInput$LexiconNames",
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "LexiconNames",
 ,
-+
+)
 .with_http_query("LexiconNames");
 static PRESIGNED_MEMBER_OUTPUT_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned#SynthesizeSpeechInput$OutputFormat",
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "OutputFormat",
 ,
-+
+)
 .with_http_query("OutputFormat");
 static PRESIGNED_MEMBER_SAMPLE_RATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned#SynthesizeSpeechInput$SampleRate",
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "SampleRate",
 ,
-+
+)
 .with_http_query("SampleRate");
 static PRESIGNED_MEMBER_SPEECH_MARK_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned#SynthesizeSpeechInput$SpeechMarkTypes",
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "SpeechMarkTypes",
 ,
-+
+)
 .with_http_query("SpeechMarkTypes");
 static PRESIGNED_MEMBER_TEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned#SynthesizeSpeechInput$Text",
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "Text",
 ,
-+
+)
 .with_http_query("Text");
 static PRESIGNED_MEMBER_TEXT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned#SynthesizeSpeechInput$TextType",
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "TextType",
 ,
-+
+)
 .with_http_query("TextType");
 static PRESIGNED_MEMBER_VOICE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned#SynthesizeSpeechInput$VoiceId",
         "com.amazonaws.polly.synthetic.synthetic.aws.presigned",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "VoiceId",
 ,
-+
+)
 .with_http_query("VoiceId");
 static PRESIGNED_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PRESIGNED_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PRESIGNED_MEMBER_ENGINE,
         &PRESIGNED_MEMBER_LANGUAGE_CODE,
         &PRESIGNED_MEMBER_LEXICON_NAMES,
         &PRESIGNED_MEMBER_OUTPUT_FORMAT,
         &PRESIGNED_MEMBER_SAMPLE_RATE,
         &PRESIGNED_MEMBER_SPEECH_MARK_TYPES,
         &PRESIGNED_MEMBER_TEXT,
         &PRESIGNED_MEMBER_TEXT_TYPE,
         &PRESIGNED_MEMBER_VOICE_ID,
     ],
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/v1/speech", None));
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for SynthesizeSpeech {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         let mut cfg = ::aws_smithy_types::config_bag::Layer::new("SynthesizeSpeech");
-216
         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
             SynthesizeSpeechRequestSerializer,
         ));
         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
             SynthesizeSpeechResponseDeserializer,
         ));

↧ Expand context

-223
         cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
             crate::config::auth::Params::builder()
                 .operation_name("SynthesizeSpeech")
                 .build()
                 .expect("required fields set"),
         ));
-230
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("SynthesizeSpeech", "Polly"));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = true;
         signing_options.content_sha256_header = false;
         signing_options.normalize_uri_path = true;
         signing_options.payload_override = None;
-237
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-242

@@ -132,258 +249,594 @@

↥ Expand context

                 crate::operation::synthesize_speech::SynthesizeSpeechError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::synthesize_speech::SynthesizeSpeechError,
             >::new());
-263
         ::std::borrow::Cow::Owned(rcb)
-265
+    }
-266
+}
-267
 #[derive(Debug)]
 struct SynthesizeSpeechResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for SynthesizeSpeechResponseDeserializer {
     fn deserialize_streaming(
         &self,
         response: &mut ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::std::option::Option<::aws_smithy_runtime_api::client::interceptors::context::OutputOrError> {
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));

-278
         // If this is an error, defer to the non-streaming parser
         if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {
             return ::std::option::Option::None;
-282
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_synthesize_speech::de_synthesize_speech_http_response(response),
         ))
-286
+    }
-287
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         // For streaming operations, we only hit this case if its an error
         let body = response.body().bytes().expect("body loaded");
         crate::protocol_serde::type_erase_result(crate::protocol_serde::shape_synthesize_speech::de_synthesize_speech_http_error(
             response.status().as_u16(),
             response.headers(),
             body,
         let status = response.status().as_u16();
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
             ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         })?;
         generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         let generic = generic_builder.build();
         let error_code = match generic.code() {
             ::std::option::Option::Some(code) => code,
             ::std::option::Option::None => {
                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                     ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::synthesize_speech::SynthesizeSpeechError::unhandled(
                         generic,
                     )),
                 ))
-+
+            }
         };
         let _error_message = generic.message().map(|msg| msg.to_owned());
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let err = match error_code {
             "EngineNotSupportedException" => crate::operation::synthesize_speech::SynthesizeSpeechError::EngineNotSupportedException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::EngineNotSupportedException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::EngineNotSupportedException::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "InvalidSampleRateException" => crate::operation::synthesize_speech::SynthesizeSpeechError::InvalidSampleRateException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::InvalidSampleRateException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::InvalidSampleRateException::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "InvalidSsmlException" => crate::operation::synthesize_speech::SynthesizeSpeechError::InvalidSsmlException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::InvalidSsmlException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::InvalidSsmlException::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "LanguageNotSupportedException" => crate::operation::synthesize_speech::SynthesizeSpeechError::LanguageNotSupportedException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::LanguageNotSupportedException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::LanguageNotSupportedException::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "LexiconNotFoundException" => crate::operation::synthesize_speech::SynthesizeSpeechError::LexiconNotFoundException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::LexiconNotFoundException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::LexiconNotFoundException::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "MarksNotSupportedForFormatException" => {
                 crate::operation::synthesize_speech::SynthesizeSpeechError::MarksNotSupportedForFormatException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::MarksNotSupportedForFormatException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::MarksNotSupportedForFormatException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 })
-+
+            }
             "ServiceFailureException" => crate::operation::synthesize_speech::SynthesizeSpeechError::ServiceFailureException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ServiceFailureException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ServiceFailureException::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "SsmlMarksNotSupportedForTextTypeException" => {
                 crate::operation::synthesize_speech::SynthesizeSpeechError::SsmlMarksNotSupportedForTextTypeException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::SsmlMarksNotSupportedForTextTypeException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::SsmlMarksNotSupportedForTextTypeException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 })
-+
+            }
             "TextLengthExceededException" => crate::operation::synthesize_speech::SynthesizeSpeechError::TextLengthExceededException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::TextLengthExceededException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::TextLengthExceededException::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             _ => crate::operation::synthesize_speech::SynthesizeSpeechError::generic(generic),
         };
         ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
             ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         ))
-543
+    }
-544
+}
 #[derive(Debug)]
 struct SynthesizeSpeechRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for SynthesizeSpeechRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::synthesize_speech::SynthesizeSpeechInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::synthesize_speech::SynthesizeSpeechInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v1/speech").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::synthesize_speech::SynthesizeSpeechInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_synthesize_speech::ser_synthesize_speech_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, SynthesizeSpeech::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-565
+    }
-566
+}
 #[derive(Debug)]
 struct SynthesizeSpeechEndpointParamsInterceptor;
-569
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SynthesizeSpeechEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "SynthesizeSpeechEndpointParamsInterceptor"
-573
+    }
-574

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<SynthesizeSpeechInput>()
             .ok_or("failed to downcast to SynthesizeSpeechInput")?;
-589
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

@@ -440,785 +563,824 @@

↥ Expand context

-785
+}
 impl ::aws_types::request_id::RequestId for crate::operation::synthesize_speech::SynthesizeSpeechError {
     fn request_id(&self) -> Option<&str> {
         self.meta().request_id()
-789
+    }
-790
+}
-791
 pub use crate::operation::synthesize_speech::_synthesize_speech_input::SynthesizeSpeechInput;
-793
 pub use crate::operation::synthesize_speech::_synthesize_speech_output::SynthesizeSpeechOutput;
-795
 mod _synthesize_speech_input;
-797
 mod _synthesize_speech_output;
-799
 /// Builders
 pub mod builders;
-802
 #[derive(Debug)]
 struct SynthesizeSpeechPresigningRequestSerializer;

 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for SynthesizeSpeechPresigningRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::synthesize_speech::SynthesizeSpeechInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::synthesize_speech::SynthesizeSpeechInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v1/speech").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::synthesize_speech::SynthesizeSpeechInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_1) = &_input.engine {
--
+                    {
                         query.push_kv("Engine", &::aws_smithy_http::query::fmt_string(inner_1.as_str()));
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.language_code {
--
+                    {
                         query.push_kv("LanguageCode", &::aws_smithy_http::query::fmt_string(inner_2.as_str()));
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.lexicon_names {
--
+                    {
                         for inner_4 in inner_3 {
                             query.push_kv("LexiconNames", &::aws_smithy_http::query::fmt_string(inner_4));
--
+                        }
--
+                    }
--
+                }
                 let inner_5 = &_input.output_format;
                 let inner_5 = inner_5
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("output_format", "cannot be empty or unset"))?;
                 query.push_kv("OutputFormat", &::aws_smithy_http::query::fmt_string(inner_5.as_str()));
                 if let ::std::option::Option::Some(inner_6) = &_input.sample_rate {
--
+                    {
                         query.push_kv("SampleRate", &::aws_smithy_http::query::fmt_string(inner_6));
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_7) = &_input.speech_mark_types {
--
+                    {
                         for inner_8 in inner_7 {
                             query.push_kv("SpeechMarkTypes", &::aws_smithy_http::query::fmt_string(inner_8.as_str()));
--
+                        }
--
+                    }
--
+                }
                 let inner_9 = &_input.text;
                 let inner_9 = inner_9
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("text", "cannot be empty or unset"))?;
                 if inner_9.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "text",
                         "cannot be empty or unset",
                     ));
--
+                }
                 query.push_kv("Text", &::aws_smithy_http::query::fmt_string(inner_9));
                 if let ::std::option::Option::Some(inner_10) = &_input.text_type {
--
+                    {
                         query.push_kv("TextType", &::aws_smithy_http::query::fmt_string(inner_10.as_str()));
--
+                    }
--
+                }
                 let inner_11 = &_input.voice_id;
                 let inner_11 = inner_11
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("voice_id", "cannot be empty or unset"))?;
                 query.push_kv("VoiceId", &::aws_smithy_http::query::fmt_string(inner_11.as_str()));
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::synthesize_speech::SynthesizeSpeechInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::empty();
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, SynthesizeSpeech::PRESIGNED_INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-821
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-823
+    }
-824
+}

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/synthesize_speech/_synthesize_speech_input.rs

@@ -57,57 +342,342 @@

↥ Expand context

     ///
     /// 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()
-61
+    }
     /// <p>Input text to synthesize. If you specify <code>ssml</code> as the <code>TextType</code>, follow the SSML format for the input text.</p>
     pub fn text(&self) -> ::std::option::Option<&str> {
         self.text.as_deref()
-65
+    }
     /// <p>Specifies whether the input text is plain text or SSML. The default value is plain text. For more information, see <a href="https://docs.aws.amazon.com/polly/latest/dg/ssml.html">Using SSML</a>.</p>
     pub fn text_type(&self) -> ::std::option::Option<&crate::types::TextType> {
         self.text_type.as_ref()
-69
+    }
     /// <p>Voice ID to use for the synthesis. You can get a list of available voice IDs by calling the <a href="https://docs.aws.amazon.com/polly/latest/dg/API_DescribeVoices.html">DescribeVoices</a> operation.</p>
     pub fn voice_id(&self) -> ::std::option::Option<&crate::types::VoiceId> {
         self.voice_id.as_ref()
-73
+    }
-74
+}
 static SYNTHESIZESPEECHINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.polly.synthetic#SynthesizeSpeechInput",

     "com.amazonaws.polly.synthetic",
     "SynthesizeSpeechInput",
 );
 static SYNTHESIZESPEECHINPUT_MEMBER_ENGINE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#SynthesizeSpeechInput$Engine",
         "com.amazonaws.polly.synthetic",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "engine",
     "Engine",
 ,
 );
 static SYNTHESIZESPEECHINPUT_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#SynthesizeSpeechInput$LanguageCode",
         "com.amazonaws.polly.synthetic",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_code",
     "LanguageCode",
 ,
 );
 static SYNTHESIZESPEECHINPUT_MEMBER_LEXICON_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#SynthesizeSpeechInput$LexiconNames",
         "com.amazonaws.polly.synthetic",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "lexicon_names",
     "LexiconNames",
 ,
 );
 static SYNTHESIZESPEECHINPUT_MEMBER_OUTPUT_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#SynthesizeSpeechInput$OutputFormat",
         "com.amazonaws.polly.synthetic",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "output_format",
     "OutputFormat",
 ,
 );
 static SYNTHESIZESPEECHINPUT_MEMBER_SAMPLE_RATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#SynthesizeSpeechInput$SampleRate",
         "com.amazonaws.polly.synthetic",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sample_rate",
     "SampleRate",
 ,
 );
 static SYNTHESIZESPEECHINPUT_MEMBER_SPEECH_MARK_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#SynthesizeSpeechInput$SpeechMarkTypes",
         "com.amazonaws.polly.synthetic",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "speech_mark_types",
     "SpeechMarkTypes",
 ,
 );
 static SYNTHESIZESPEECHINPUT_MEMBER_TEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#SynthesizeSpeechInput$Text",
         "com.amazonaws.polly.synthetic",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "text",
     "Text",
 ,
 );
 static SYNTHESIZESPEECHINPUT_MEMBER_TEXT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#SynthesizeSpeechInput$TextType",
         "com.amazonaws.polly.synthetic",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "text_type",
     "TextType",
 ,
 );
 static SYNTHESIZESPEECHINPUT_MEMBER_VOICE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#SynthesizeSpeechInput$VoiceId",
         "com.amazonaws.polly.synthetic",
         "SynthesizeSpeechInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "voice_id",
     "VoiceId",
 ,
 );
 static SYNTHESIZESPEECHINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SYNTHESIZESPEECHINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SYNTHESIZESPEECHINPUT_MEMBER_ENGINE,
         &SYNTHESIZESPEECHINPUT_MEMBER_LANGUAGE_CODE,
         &SYNTHESIZESPEECHINPUT_MEMBER_LEXICON_NAMES,
         &SYNTHESIZESPEECHINPUT_MEMBER_OUTPUT_FORMAT,
         &SYNTHESIZESPEECHINPUT_MEMBER_SAMPLE_RATE,
         &SYNTHESIZESPEECHINPUT_MEMBER_SPEECH_MARK_TYPES,
         &SYNTHESIZESPEECHINPUT_MEMBER_TEXT,
         &SYNTHESIZESPEECHINPUT_MEMBER_TEXT_TYPE,
         &SYNTHESIZESPEECHINPUT_MEMBER_VOICE_ID,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/v1/speech", None));
 impl SynthesizeSpeechInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SYNTHESIZESPEECHINPUT_SCHEMA;
-189
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SynthesizeSpeechInput {
     #[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.engine {
             ser.write_string(&SYNTHESIZESPEECHINPUT_MEMBER_ENGINE, val.as_str())?;
-198
+        }
         if let Some(ref val) = self.language_code {
             ser.write_string(&SYNTHESIZESPEECHINPUT_MEMBER_LANGUAGE_CODE, val.as_str())?;
-201
+        }
         if let Some(ref val) = self.lexicon_names {
             ser.write_list(
                 &SYNTHESIZESPEECHINPUT_MEMBER_LEXICON_NAMES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-208
+                    }
                     Ok(())
                 },
             )?;
-212
+        }
         if let Some(ref val) = self.output_format {
             ser.write_string(&SYNTHESIZESPEECHINPUT_MEMBER_OUTPUT_FORMAT, val.as_str())?;
-215
+        }
         if let Some(ref val) = self.sample_rate {
             ser.write_string(&SYNTHESIZESPEECHINPUT_MEMBER_SAMPLE_RATE, val)?;
-218
+        }
         if let Some(ref val) = self.speech_mark_types {
             ser.write_list(
                 &SYNTHESIZESPEECHINPUT_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())?;
-225
+                    }
                     Ok(())
                 },
             )?;
-229
+        }
         if let Some(ref val) = self.text {
             ser.write_string(&SYNTHESIZESPEECHINPUT_MEMBER_TEXT, val)?;
-232
+        }
         if let Some(ref val) = self.text_type {
             ser.write_string(&SYNTHESIZESPEECHINPUT_MEMBER_TEXT_TYPE, val.as_str())?;
-235
+        }
         if let Some(ref val) = self.voice_id {
             ser.write_string(&SYNTHESIZESPEECHINPUT_MEMBER_VOICE_ID, val.as_str())?;
-238
+        }
         Ok(())
-240
+    }
-241
+}
 impl SynthesizeSpeechInput {
     /// 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(&SYNTHESIZESPEECHINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SYNTHESIZESPEECHINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.engine = Some(crate::types::Engine::from(deser.read_string(member)?.as_str()));
-260
+                }
                 Some(1) => {
                     builder.language_code = Some(crate::types::LanguageCode::from(deser.read_string(member)?.as_str()));
-263
+                }
                 Some(2) => {
                     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)?);
-266
+                }
                 Some(3) => {
                     builder.output_format = Some(crate::types::OutputFormat::from(deser.read_string(member)?.as_str()));
-269
+                }
                 Some(4) => {
                     builder.sample_rate = Some(deser.read_string(member)?);
-272
+                }
                 Some(5) => {
                     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
                     });
-282
+                }
                 Some(6) => {
                     builder.text = Some(deser.read_string(member)?);
-285
+                }
                 Some(7) => {
                     builder.text_type = Some(crate::types::TextType::from(deser.read_string(member)?.as_str()));
-288
+                }
                 Some(8) => {
                     builder.voice_id = Some(crate::types::VoiceId::from(deser.read_string(member)?.as_str()));
-291
+                }
                 _ => {}
-293
+            }
             Ok(())
         })?;
         builder.text = builder.text.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-300
+    }
-301
+}
 impl SynthesizeSpeechInput {
     /// 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 SynthesizeSpeechInput {
     /// Creates a new builder-style object to manufacture [`SynthesizeSpeechInput`](crate::operation::synthesize_speech::SynthesizeSpeechInput).
     pub fn builder() -> crate::operation::synthesize_speech::builders::SynthesizeSpeechInputBuilder {
         crate::operation::synthesize_speech::builders::SynthesizeSpeechInputBuilder::default()
-317
+    }
-318
+}
-319
 /// A builder for [`SynthesizeSpeechInput`](crate::operation::synthesize_speech::SynthesizeSpeechInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SynthesizeSpeechInputBuilder {
     pub(crate) engine: ::std::option::Option<crate::types::Engine>,
     pub(crate) language_code: ::std::option::Option<crate::types::LanguageCode>,
     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: ::std::option::Option<::std::string::String>,
     pub(crate) text_type: ::std::option::Option<crate::types::TextType>,
     pub(crate) voice_id: ::std::option::Option<crate::types::VoiceId>,
-333
+}
 impl SynthesizeSpeechInputBuilder {
     /// <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. Provide an engine that is supported by the voice you select. If you don't provide an engine, the standard engine is selected by default. If a chosen voice isn't supported by the standard engine, this will result in an error. For information on Amazon Polly voices and which voices are available for each engine, see <a href="https://docs.aws.amazon.com/polly/latest/dg/voicelist.html">Available Voices</a>.</p>
     pub fn engine(mut self, input: crate::types::Engine) -> Self {
         self.engine = ::std::option::Option::Some(input);
         self
-339
+    }
     /// <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. Provide an engine that is supported by the voice you select. If you don't provide an engine, the standard engine is selected by default. If a chosen voice isn't supported by the standard engine, this will result in an error. For information on Amazon Polly voices and which voices are available for each engine, see <a href="https://docs.aws.amazon.com/polly/latest/dg/voicelist.html">Available Voices</a>.</p>
     pub fn set_engine(mut self, input: ::std::option::Option<crate::types::Engine>) -> Self {
         self.engine = input;

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/synthesize_speech/_synthesize_speech_output.rs

@@ -32,32 +178,230 @@

↥ Expand context

     /// <li>
     /// <p>If you request <code>mp3</code> as the <code>OutputFormat</code>, the <code>ContentType</code> returned is audio/mpeg.</p></li>
     /// <li>
     /// <p>If you request <code>ogg_vorbis</code> as the <code>OutputFormat</code>, the <code>ContentType</code> returned is audio/ogg.</p></li>
     /// <li>
     /// <p>If you request <code>pcm</code> as the <code>OutputFormat</code>, the <code>ContentType</code> returned is audio/pcm in a signed 16-bit, 1 channel (mono), little-endian format.</p></li>
     /// <li>
     /// <p>If you request <code>json</code> as the <code>OutputFormat</code>, the <code>ContentType</code> returned is application/x-json-stream.</p></li>
     /// </ul>
     /// <p></p>
     pub fn content_type(&self) -> ::std::option::Option<&str> {
         self.content_type.as_deref()
-44
+    }
     /// <p>Number of characters synthesized.</p>
     pub fn request_characters(&self) -> i32 {
         self.request_characters
-48
+    }
-49
+}
 static SYNTHESIZESPEECHOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.polly.synthetic#SynthesizeSpeechOutput",

     "com.amazonaws.polly.synthetic",
     "SynthesizeSpeechOutput",
 );
 static SYNTHESIZESPEECHOUTPUT_MEMBER_AUDIO_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#SynthesizeSpeechOutput$AudioStream",
         "com.amazonaws.polly.synthetic",
         "SynthesizeSpeechOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "audio_stream",
     "AudioStream",
 ,
-64
+)
 .with_http_payload();
 static SYNTHESIZESPEECHOUTPUT_MEMBER_CONTENT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#SynthesizeSpeechOutput$ContentType",
         "com.amazonaws.polly.synthetic",
         "SynthesizeSpeechOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content_type",
     "ContentType",
 ,
-75
+)
 .with_http_header("Content-Type");
 static SYNTHESIZESPEECHOUTPUT_MEMBER_REQUEST_CHARACTERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#SynthesizeSpeechOutput$RequestCharacters",
         "com.amazonaws.polly.synthetic",
         "SynthesizeSpeechOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "request_characters",
     "RequestCharacters",
 ,
-86
+)
 .with_http_header("x-amzn-RequestCharacters");
 static SYNTHESIZESPEECHOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static SYNTHESIZESPEECHOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SYNTHESIZESPEECHOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SYNTHESIZESPEECHOUTPUT_MEMBER_AUDIO_STREAM,
         &SYNTHESIZESPEECHOUTPUT_MEMBER_CONTENT_TYPE,
         &SYNTHESIZESPEECHOUTPUT_MEMBER_REQUEST_CHARACTERS,
         &SYNTHESIZESPEECHOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl SynthesizeSpeechOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SYNTHESIZESPEECHOUTPUT_SCHEMA;
-108
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SynthesizeSpeechOutput {
     #[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> {
--
+        {
             let val = &self.audio_stream;
             // streaming blob is serialized as the HTTP body by the protocol, not the codec
--
+        }
         if let Some(ref val) = self.content_type {
             ser.write_string(&SYNTHESIZESPEECHOUTPUT_MEMBER_CONTENT_TYPE, val)?;
-117
+        }
-118
+        {
             let val = &self.request_characters;
             ser.write_integer(&SYNTHESIZESPEECHOUTPUT_MEMBER_REQUEST_CHARACTERS, *val)?;
-121
+        }
         Ok(())
-123
+    }
-124
+}
 impl SynthesizeSpeechOutput {
     /// 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(&SYNTHESIZESPEECHOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SYNTHESIZESPEECHOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.audio_stream = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-146
+                }
                 Some(1) => {
                     builder.content_type = Some(deser.read_string(member)?);
-149
+                }
                 Some(2) => {
                     builder.request_characters = Some(deser.read_integer(member)?);
-152
+                }
                 Some(3) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl SynthesizeSpeechOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("Content-Type") {
             builder.content_type = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-RequestCharacters") {
             builder.request_characters = val.parse::<i32>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&SYNTHESIZESPEECHOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.audio_stream = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-+
+                }
                 Some(1) => { /* read from headers above */ }
                 Some(2) => { /* read from headers above */ }
                 _ => {}
-202
+            }
             Ok(())
         })?;
         Ok(builder.build())
-206
+    }
-207
+}
 impl ::aws_types::request_id::RequestId for SynthesizeSpeechOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()

↧ Expand context

-211
+    }
-212
+}
 impl SynthesizeSpeechOutput {
     /// Creates a new builder-style object to manufacture [`SynthesizeSpeechOutput`](crate::operation::synthesize_speech::SynthesizeSpeechOutput).
     pub fn builder() -> crate::operation::synthesize_speech::builders::SynthesizeSpeechOutputBuilder {
         crate::operation::synthesize_speech::builders::SynthesizeSpeechOutputBuilder::default()
-217
+    }
-218
+}
-219
 /// A builder for [`SynthesizeSpeechOutput`](crate::operation::synthesize_speech::SynthesizeSpeechOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct SynthesizeSpeechOutputBuilder {
     pub(crate) audio_stream: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>,
     pub(crate) content_type: ::std::option::Option<::std::string::String>,
     pub(crate) request_characters: ::std::option::Option<i32>,
     _request_id: Option<String>,
-228
+}
 impl SynthesizeSpeechOutputBuilder {
     /// <p>Stream containing the synthesized speech.</p>

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

@@ -1,1 +124,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub fn parse_http_error_metadata(
     _response_status: u16,
     response_headers: &::aws_smithy_runtime_api::http::Headers,
     response_body: &[u8],
 ) -> ::std::result::Result<::aws_smithy_types::error::metadata::Builder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     crate::json_errors::parse_error_metadata(response_body, response_headers)
-+
+}
-+
 pub(crate) fn type_erase_result<O, E>(
     result: ::std::result::Result<O, E>,
 ) -> ::std::result::Result<
     ::aws_smithy_runtime_api::client::interceptors::context::Output,
     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError<::aws_smithy_runtime_api::client::interceptors::context::Error>,
-15
+>
 where
     O: ::std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
     E: ::std::error::Error + std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
-19
+{
     result
         .map(|output| ::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         .map_err(|error| ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(error))
         .map_err(::std::convert::Into::into)
-24
+}
-25
 pub fn parse_http_error_metadata(
     _response_status: u16,
     response_headers: &::aws_smithy_runtime_api::http::Headers,
     response_body: &[u8],
 ) -> ::std::result::Result<::aws_smithy_types::error::metadata::Builder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     crate::json_errors::parse_error_metadata(response_body, response_headers)
--
+}
--
 pub(crate) mod shape_delete_lexicon;
--
 pub(crate) mod shape_describe_voices;
--
 pub(crate) mod shape_get_lexicon;
--
 pub(crate) mod shape_get_speech_synthesis_task;
--
 pub(crate) mod shape_list_lexicons;
--
 pub(crate) mod shape_list_speech_synthesis_tasks;
--
 pub(crate) mod shape_put_lexicon;
--
 pub(crate) mod shape_start_speech_synthesis_task;
--
 pub(crate) mod shape_synthesize_speech;
-27
 pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
     if data.is_empty() {
         b"{}"
     } else {
         data
--
+    }
--
+}
--
 pub(crate) mod shape_engine_not_supported_exception;
--
 pub(crate) mod shape_invalid_lexicon_exception;
--
 pub(crate) mod shape_invalid_next_token_exception;
--
 pub(crate) mod shape_invalid_s3_bucket_exception;
--
 pub(crate) mod shape_invalid_s3_key_exception;
--
 pub(crate) mod shape_invalid_sample_rate_exception;
--
 pub(crate) mod shape_invalid_sns_topic_arn_exception;
--
 pub(crate) mod shape_invalid_ssml_exception;
--
 pub(crate) mod shape_invalid_task_id_exception;
--
 pub(crate) mod shape_language_not_supported_exception;
--
 pub(crate) mod shape_lexicon_not_found_exception;
--
 pub(crate) mod shape_lexicon_size_exceeded_exception;
--
 pub(crate) mod shape_marks_not_supported_for_format_exception;
--
 pub(crate) mod shape_max_lexeme_length_exceeded_exception;
--
 pub(crate) mod shape_max_lexicons_number_exceeded_exception;
--
 pub(crate) mod shape_put_lexicon_input;
--
 pub(crate) mod shape_service_failure_exception;
--
 pub(crate) mod shape_ssml_marks_not_supported_for_text_type_exception;
--
 pub(crate) mod shape_start_speech_synthesis_task_input;
--
 pub(crate) mod shape_synthesis_task_not_found_exception;
--
 pub(crate) mod shape_synthesize_speech_input;
--
 pub(crate) mod shape_synthesize_speech_output;
--
 pub(crate) mod shape_text_length_exceeded_exception;
--
 pub(crate) mod shape_unsupported_pls_alphabet_exception;
--
 pub(crate) mod shape_unsupported_pls_language_exception;
--
 pub(crate) mod shape_lexicon;
--
 pub(crate) mod shape_lexicon_attributes;
--
 pub(crate) mod shape_lexicon_description_list;
--
 pub(crate) mod shape_synthesis_task;
--
 pub(crate) mod shape_synthesis_tasks;
--
 pub(crate) mod shape_voice_list;
--
 pub(crate) mod shape_lexicon_description;
--
 pub(crate) mod shape_lexicon_name_list;
--
 pub(crate) mod shape_speech_mark_type_list;
--
 pub(crate) mod shape_voice;
--
 pub(crate) mod shape_engine_list;
--
 pub(crate) mod shape_language_code_list;

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_lexicon_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::delete_lexicon::DeleteLexiconOutput, crate::operation::delete_lexicon::DeleteLexiconError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::delete_lexicon::DeleteLexiconError::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::delete_lexicon::DeleteLexiconError::unhandled(generic)),
     };
--
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {
         "LexiconNotFoundException" => crate::operation::delete_lexicon::DeleteLexiconError::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::delete_lexicon::DeleteLexiconError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ServiceFailureException" => crate::operation::delete_lexicon::DeleteLexiconError::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::delete_lexicon::DeleteLexiconError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::delete_lexicon::DeleteLexiconError::generic(generic),
     })
--
+}
--
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_lexicon_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::delete_lexicon::DeleteLexiconOutput, crate::operation::delete_lexicon::DeleteLexiconError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_lexicon::builders::DeleteLexiconOutputBuilder::default();
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
--
+}

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_describe_voices_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::describe_voices::DescribeVoicesOutput, crate::operation::describe_voices::DescribeVoicesError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::describe_voices::DescribeVoicesError::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::describe_voices::DescribeVoicesError::unhandled(generic)),
     };
--
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {
         "InvalidNextTokenException" => crate::operation::describe_voices::DescribeVoicesError::InvalidNextTokenException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidNextTokenExceptionBuilder::default();
                 output = crate::protocol_serde::shape_invalid_next_token_exception::de_invalid_next_token_exception_json_err(_response_body, output)
                     .map_err(crate::operation::describe_voices::DescribeVoicesError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ServiceFailureException" => crate::operation::describe_voices::DescribeVoicesError::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::describe_voices::DescribeVoicesError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::describe_voices::DescribeVoicesError::generic(generic),
     })
--
+}
--
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_describe_voices_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::describe_voices::DescribeVoicesOutput, crate::operation::describe_voices::DescribeVoicesError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::describe_voices::builders::DescribeVoicesOutputBuilder::default();
         output = crate::protocol_serde::shape_describe_voices::de_describe_voices(_response_body, output)
             .map_err(crate::operation::describe_voices::DescribeVoicesError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
--
+}
--
 pub(crate) fn de_describe_voices(
     _value: &[u8],
     mut builder: crate::operation::describe_voices::builders::DescribeVoicesOutputBuilder,
 ) -> ::std::result::Result<
     crate::operation::describe_voices::builders::DescribeVoicesOutputBuilder,
     ::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() {
                 "NextToken" => {
                     builder = builder.set_next_token(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 "Voices" => {
                     builder = builder.set_voices(crate::protocol_serde::shape_voice_list::de_voice_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:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

AWS SDK

Files changed:

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/start_speech_synthesis_task/_start_speech_synthesis_task_input.rs

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/start_speech_synthesis_task/_start_speech_synthesis_task_output.rs

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/synthesize_speech.rs

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/synthesize_speech/_synthesize_speech_input.rs

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/synthesize_speech/_synthesize_speech_output.rs

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

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

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