AWS SDK

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

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

 // 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 GetSpeechSynthesisTaskOutput {
     /// <p>SynthesisTask object that provides information from the requested task, including output format, creation time, task status, and so on.</p>
     pub synthesis_task: ::std::option::Option<crate::types::SynthesisTask>,
     _request_id: Option<String>,
-9
+}
 impl GetSpeechSynthesisTaskOutput {
     /// <p>SynthesisTask object that provides information from the requested task, including output format, creation time, task status, and so on.</p>
     pub fn synthesis_task(&self) -> ::std::option::Option<&crate::types::SynthesisTask> {
         self.synthesis_task.as_ref()
-14
+    }
-15
+}
 static GETSPEECHSYNTHESISTASKOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.polly.synthetic#GetSpeechSynthesisTaskOutput",

     "com.amazonaws.polly.synthetic",
     "GetSpeechSynthesisTaskOutput",
 );
 static GETSPEECHSYNTHESISTASKOUTPUT_MEMBER_SYNTHESIS_TASK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#GetSpeechSynthesisTaskOutput$SynthesisTask",
         "com.amazonaws.polly.synthetic",
         "GetSpeechSynthesisTaskOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "synthesis_task",
     "SynthesisTask",
 ,
 );
 static GETSPEECHSYNTHESISTASKOUTPUT_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 GETSPEECHSYNTHESISTASKOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETSPEECHSYNTHESISTASKOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GETSPEECHSYNTHESISTASKOUTPUT_MEMBER_SYNTHESIS_TASK],
     &[
         &GETSPEECHSYNTHESISTASKOUTPUT_MEMBER_SYNTHESIS_TASK,
         &GETSPEECHSYNTHESISTASKOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl GetSpeechSynthesisTaskOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETSPEECHSYNTHESISTASKOUTPUT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetSpeechSynthesisTaskOutput {
     #[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(&GETSPEECHSYNTHESISTASKOUTPUT_MEMBER_SYNTHESIS_TASK, val)?;
-58
+        }
         Ok(())
-60
+    }
-61
+}
 impl GetSpeechSynthesisTaskOutput {
     /// 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(&GETSPEECHSYNTHESISTASKOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETSPEECHSYNTHESISTASKOUTPUT_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 GetSpeechSynthesisTaskOutput {
     /// 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(&GETSPEECHSYNTHESISTASKOUTPUT_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 GetSpeechSynthesisTaskOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-128
+    }
-129
+}
 impl GetSpeechSynthesisTaskOutput {
     /// Creates a new builder-style object to manufacture [`GetSpeechSynthesisTaskOutput`](crate::operation::get_speech_synthesis_task::GetSpeechSynthesisTaskOutput).
     pub fn builder() -> crate::operation::get_speech_synthesis_task::builders::GetSpeechSynthesisTaskOutputBuilder {
         crate::operation::get_speech_synthesis_task::builders::GetSpeechSynthesisTaskOutputBuilder::default()
-134
+    }
-135
+}
-136
 /// A builder for [`GetSpeechSynthesisTaskOutput`](crate::operation::get_speech_synthesis_task::GetSpeechSynthesisTaskOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetSpeechSynthesisTaskOutputBuilder {
     pub(crate) synthesis_task: ::std::option::Option<crate::types::SynthesisTask>,
     _request_id: Option<String>,
-143
+}

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `ListLexicons`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListLexicons;
 impl ListLexicons {
     /// Creates a new `ListLexicons`
     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::list_lexicons::ListLexiconsInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::list_lexicons::ListLexiconsOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::list_lexicons::ListLexiconsInput,
     ) -> ::std::result::Result<
         crate::operation::list_lexicons::ListLexiconsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::list_lexicons::ListLexiconsError,
             ::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::list_lexicons::ListLexiconsError>()
                     .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::list_lexicons::ListLexiconsOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -115,119 +246,303 @@

↥ Expand context

         });
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ListLexicons")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListLexiconsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_lexicons::ListLexiconsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_lexicons::ListLexiconsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::list_lexicons::ListLexiconsError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct ListLexiconsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListLexiconsResponseDeserializer {
     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 {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_list_lexicons::de_list_lexicons_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[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::list_lexicons::ListLexiconsError::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 {
                 "InvalidNextTokenException" => crate::operation::list_lexicons::ListLexiconsError::InvalidNextTokenException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidNextTokenException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidNextTokenException::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::list_lexicons::ListLexiconsError::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
                 }),
                 _ => crate::operation::list_lexicons::ListLexiconsError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_list_lexicons::de_list_lexicons_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, ListLexicons::OUTPUT_SCHEMA, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::list_lexicons::ListLexiconsOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-252
+    }
-253
+}
 #[derive(Debug)]
 struct ListLexiconsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListLexiconsRequestSerializer {
     #[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::list_lexicons::ListLexiconsInput>()
             .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::list_lexicons::ListLexiconsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v1/lexicons").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::list_lexicons::ListLexiconsInput,
                 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.next_token {
--
+                    {
                         query.push_kv("NextToken", &::aws_smithy_http::query::fmt_string(inner_1));
--
+                    }
--
+                }
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_lexicons::ListLexiconsInput,
                 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::from("");
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, ListLexicons::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-272
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-274
+    }
-275
+}
 #[derive(Debug)]
 struct ListLexiconsEndpointParamsInterceptor;
-278
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListLexiconsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListLexiconsEndpointParamsInterceptor"
-282
+    }
-283

↧ 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::<ListLexiconsInput>()
             .ok_or("failed to downcast to ListLexiconsInput")?;
-298
         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()))

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

@@ -1,1 +109,121 @@

↥ 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 ListLexiconsInput {
     /// <p>An opaque pagination token returned from previous <code>ListLexicons</code> operation. If present, indicates where to continue the list of lexicons.</p>
     pub next_token: ::std::option::Option<::std::string::String>,
-8
+}
 impl ListLexiconsInput {
     /// <p>An opaque pagination token returned from previous <code>ListLexicons</code> operation. If present, indicates where to continue the list of lexicons.</p>
     pub fn next_token(&self) -> ::std::option::Option<&str> {
         self.next_token.as_deref()
-13
+    }
-14
+}
 static LISTLEXICONSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.polly.synthetic#ListLexiconsInput",

     "com.amazonaws.polly.synthetic",
     "ListLexiconsInput",
 );
 static LISTLEXICONSINPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#ListLexiconsInput$NextToken",
         "com.amazonaws.polly.synthetic",
         "ListLexiconsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_token",
     "NextToken",
 ,
-29
+)
 .with_http_query("NextToken");
 static LISTLEXICONSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTLEXICONSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&LISTLEXICONSINPUT_MEMBER_NEXT_TOKEN],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/v1/lexicons", None));
 impl ListLexiconsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTLEXICONSINPUT_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListLexiconsInput {
     #[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.next_token {
             ser.write_string(&LISTLEXICONSINPUT_MEMBER_NEXT_TOKEN, val)?;
-49
+        }
         Ok(())
-51
+    }
-52
+}
 impl ListLexiconsInput {
     /// 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(&LISTLEXICONSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTLEXICONSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.next_token = Some(deser.read_string(member)?);
-71
+                }
                 _ => {}
-73
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-79
+    }
-80
+}
 impl ListLexiconsInput {
     /// 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 ListLexiconsInput {
     /// Creates a new builder-style object to manufacture [`ListLexiconsInput`](crate::operation::list_lexicons::ListLexiconsInput).
     pub fn builder() -> crate::operation::list_lexicons::builders::ListLexiconsInputBuilder {
         crate::operation::list_lexicons::builders::ListLexiconsInputBuilder::default()
-96
+    }
-97
+}
-98
 /// A builder for [`ListLexiconsInput`](crate::operation::list_lexicons::ListLexiconsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ListLexiconsInputBuilder {
     pub(crate) next_token: ::std::option::Option<::std::string::String>,
-104
+}
 impl ListLexiconsInputBuilder {
     /// <p>An opaque pagination token returned from previous <code>ListLexicons</code> operation. If present, indicates where to continue the list of lexicons.</p>
     pub fn next_token(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.next_token = ::std::option::Option::Some(input.into());
         self
-110
+    }
     /// <p>An opaque pagination token returned from previous <code>ListLexicons</code> operation. If present, indicates where to continue the list of lexicons.</p>
     pub fn set_next_token(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.next_token = input;
         self
-115
+    }
     /// <p>An opaque pagination token returned from previous <code>ListLexicons</code> operation. If present, indicates where to continue the list of lexicons.</p>
     pub fn get_next_token(&self) -> &::std::option::Option<::std::string::String> {
         &self.next_token
-119
+    }
     /// Consumes the builder and constructs a [`ListLexiconsInput`](crate::operation::list_lexicons::ListLexiconsInput).
     pub fn build(

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

@@ -6,6 +137,192 @@

↥ Expand context

     /// <p>A list of lexicon names and attributes.</p>
     pub lexicons: ::std::option::Option<::std::vec::Vec<crate::types::LexiconDescription>>,
     /// <p>The pagination token to use in the next request to continue the listing of lexicons. <code>NextToken</code> is returned only if the response is truncated.</p>
     pub next_token: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-11
+}
 impl ListLexiconsOutput {
     /// <p>A list of lexicon names and attributes.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.lexicons.is_none()`.
     pub fn lexicons(&self) -> &[crate::types::LexiconDescription] {
         self.lexicons.as_deref().unwrap_or_default()
-18
+    }
     /// <p>The pagination token to use in the next request to continue the listing of lexicons. <code>NextToken</code> is returned only if the response is truncated.</p>
     pub fn next_token(&self) -> ::std::option::Option<&str> {
         self.next_token.as_deref()
-22
+    }
-23
+}
 static LISTLEXICONSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.polly.synthetic#ListLexiconsOutput",

     "com.amazonaws.polly.synthetic",
     "ListLexiconsOutput",
 );
 static LISTLEXICONSOUTPUT_MEMBER_LEXICONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#ListLexiconsOutput$Lexicons",
         "com.amazonaws.polly.synthetic",
         "ListLexiconsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "lexicons",
     "Lexicons",
 ,
 );
 static LISTLEXICONSOUTPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#ListLexiconsOutput$NextToken",
         "com.amazonaws.polly.synthetic",
         "ListLexiconsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_token",
     "NextToken",
 ,
 );
 static LISTLEXICONSOUTPUT_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 LISTLEXICONSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTLEXICONSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&LISTLEXICONSOUTPUT_MEMBER_LEXICONS, &LISTLEXICONSOUTPUT_MEMBER_NEXT_TOKEN],
     &[
         &LISTLEXICONSOUTPUT_MEMBER_LEXICONS,
         &LISTLEXICONSOUTPUT_MEMBER_NEXT_TOKEN,
         &LISTLEXICONSOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ListLexiconsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTLEXICONSOUTPUT_SCHEMA;
-68
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListLexiconsOutput {
     #[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.lexicons {
             ser.write_list(
                 &LISTLEXICONSOUTPUT_MEMBER_LEXICONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::LexiconDescription::SCHEMA, item)?;
-81
+                    }
                     Ok(())
                 },
             )?;
-85
+        }
         if let Some(ref val) = self.next_token {
             ser.write_string(&LISTLEXICONSOUTPUT_MEMBER_NEXT_TOKEN, val)?;
-88
+        }
         Ok(())
-90
+    }
-91
+}
 impl ListLexiconsOutput {
     /// 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(&LISTLEXICONSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTLEXICONSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.lexicons = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::LexiconDescription::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(1) => {
                     builder.next_token = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl ListLexiconsOutput {
     /// 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(&LISTLEXICONSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.lexicons = 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::LexiconDescription::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::LexiconDescription::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-164
+                }
                 Some(1) => {
                     builder.next_token = Some(deser.read_string(member)?);
-167
+                }
                 _ => {}
-169
+            }
             Ok(())
         })?;
         Ok(builder.build())

↧ Expand context

-173
+    }
-174
+}
 impl ::aws_types::request_id::RequestId for ListLexiconsOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-178
+    }
-179
+}
 impl ListLexiconsOutput {
     /// Creates a new builder-style object to manufacture [`ListLexiconsOutput`](crate::operation::list_lexicons::ListLexiconsOutput).
     pub fn builder() -> crate::operation::list_lexicons::builders::ListLexiconsOutputBuilder {
         crate::operation::list_lexicons::builders::ListLexiconsOutputBuilder::default()
-184
+    }
-185
+}
-186
 /// A builder for [`ListLexiconsOutput`](crate::operation::list_lexicons::ListLexiconsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListLexiconsOutputBuilder {
     pub(crate) lexicons: ::std::option::Option<::std::vec::Vec<crate::types::LexiconDescription>>,
     pub(crate) next_token: ::std::option::Option<::std::string::String>,

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

@@ -1,1 +40,46 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `ListSpeechSynthesisTasks`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListSpeechSynthesisTasks;
 impl ListSpeechSynthesisTasks {
     /// Creates a new `ListSpeechSynthesisTasks`
     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::list_speech_synthesis_tasks::ListSpeechSynthesisTasksInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksInput,
     ) -> ::std::result::Result<
         crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError,
             ::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::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError>()
                     .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::list_speech_synthesis_tasks::ListSpeechSynthesisTasksOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -118,124 +259,314 @@

↥ Expand context

         });
-125
         ::std::option::Option::Some(cfg.freeze())
-127
+    }
-128
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ListSpeechSynthesisTasks")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListSpeechSynthesisTasksEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError,
             >::new());
-146
         ::std::borrow::Cow::Owned(rcb)
-148
+    }
-149
+}
-150
 #[derive(Debug)]
 struct ListSpeechSynthesisTasksResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListSpeechSynthesisTasksResponseDeserializer {
     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 {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_list_speech_synthesis_tasks::de_list_speech_synthesis_tasks_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[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::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError::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 {
                 "InvalidNextTokenException" => {
                     crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError::InvalidNextTokenException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InvalidNextTokenException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InvalidNextTokenException::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::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError::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
                 }),
                 _ => crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_list_speech_synthesis_tasks::de_list_speech_synthesis_tasks_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, ListSpeechSynthesisTasks::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-263
+    }
-264
+}
 #[derive(Debug)]
 struct ListSpeechSynthesisTasksRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListSpeechSynthesisTasksRequestSerializer {
     #[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::list_speech_synthesis_tasks::ListSpeechSynthesisTasksInput>()
             .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::list_speech_synthesis_tasks::ListSpeechSynthesisTasksInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v1/synthesisTasks").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksInput,
                 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.max_results {
--
+                    {
                         query.push_kv("MaxResults", ::aws_smithy_types::primitive::Encoder::from(*inner_1).encode());
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.next_token {
--
+                    {
                         query.push_kv("NextToken", &::aws_smithy_http::query::fmt_string(inner_2));
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.status {
--
+                    {
                         query.push_kv("Status", &::aws_smithy_http::query::fmt_string(inner_3.as_str()));
--
+                    }
--
+                }
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksInput,
                 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::from("");
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, ListSpeechSynthesisTasks::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-283
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-285
+    }
-286
+}
 #[derive(Debug)]
 struct ListSpeechSynthesisTasksEndpointParamsInterceptor;
-289
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListSpeechSynthesisTasksEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListSpeechSynthesisTasksEndpointParamsInterceptor"
-293
+    }
-294

↧ 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::<ListSpeechSynthesisTasksInput>()
             .ok_or("failed to downcast to ListSpeechSynthesisTasksInput")?;
-309
         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()))

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

@@ -9,9 +159,171 @@

↥ Expand context

     pub next_token: ::std::option::Option<::std::string::String>,
     /// <p>Status of the speech synthesis tasks returned in a List operation</p>
     pub status: ::std::option::Option<crate::types::TaskStatus>,
-12
+}
 impl ListSpeechSynthesisTasksInput {
     /// <p>Maximum number of speech synthesis tasks returned in a List operation.</p>
     pub fn max_results(&self) -> ::std::option::Option<i32> {
         self.max_results
-17
+    }
     /// <p>The pagination token to use in the next request to continue the listing of speech synthesis tasks.</p>
     pub fn next_token(&self) -> ::std::option::Option<&str> {
         self.next_token.as_deref()
-21
+    }
     /// <p>Status of the speech synthesis tasks returned in a List operation</p>
     pub fn status(&self) -> ::std::option::Option<&crate::types::TaskStatus> {
         self.status.as_ref()
-25
+    }
-26
+}
 static LISTSPEECHSYNTHESISTASKSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.polly.synthetic#ListSpeechSynthesisTasksInput",

     "com.amazonaws.polly.synthetic",
     "ListSpeechSynthesisTasksInput",
 );
 static LISTSPEECHSYNTHESISTASKSINPUT_MEMBER_MAX_RESULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#ListSpeechSynthesisTasksInput$MaxResults",
         "com.amazonaws.polly.synthetic",
         "ListSpeechSynthesisTasksInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_results",
     "MaxResults",
 ,
-41
+)
 .with_http_query("MaxResults");
 static LISTSPEECHSYNTHESISTASKSINPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#ListSpeechSynthesisTasksInput$NextToken",
         "com.amazonaws.polly.synthetic",
         "ListSpeechSynthesisTasksInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_token",
     "NextToken",
 ,
-52
+)
 .with_http_query("NextToken");
 static LISTSPEECHSYNTHESISTASKSINPUT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#ListSpeechSynthesisTasksInput$Status",
         "com.amazonaws.polly.synthetic",
         "ListSpeechSynthesisTasksInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "status",
     "Status",
 ,
-63
+)
 .with_http_query("Status");
 static LISTSPEECHSYNTHESISTASKSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTSPEECHSYNTHESISTASKSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTSPEECHSYNTHESISTASKSINPUT_MEMBER_MAX_RESULTS,
         &LISTSPEECHSYNTHESISTASKSINPUT_MEMBER_NEXT_TOKEN,
         &LISTSPEECHSYNTHESISTASKSINPUT_MEMBER_STATUS,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/v1/synthesisTasks", None));
 impl ListSpeechSynthesisTasksInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTSPEECHSYNTHESISTASKSINPUT_SCHEMA;
-78
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListSpeechSynthesisTasksInput {
     #[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.max_results {
             ser.write_integer(&LISTSPEECHSYNTHESISTASKSINPUT_MEMBER_MAX_RESULTS, *val)?;
-87
+        }
         if let Some(ref val) = self.next_token {
             ser.write_string(&LISTSPEECHSYNTHESISTASKSINPUT_MEMBER_NEXT_TOKEN, val)?;
-90
+        }
         if let Some(ref val) = self.status {
             ser.write_string(&LISTSPEECHSYNTHESISTASKSINPUT_MEMBER_STATUS, val.as_str())?;
-93
+        }
         Ok(())
-95
+    }
-96
+}
 impl ListSpeechSynthesisTasksInput {
     /// 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(&LISTSPEECHSYNTHESISTASKSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTSPEECHSYNTHESISTASKSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.max_results = Some(deser.read_integer(member)?);
-115
+                }
                 Some(1) => {
                     builder.next_token = Some(deser.read_string(member)?);
-118
+                }
                 Some(2) => {
                     builder.status = Some(crate::types::TaskStatus::from(deser.read_string(member)?.as_str()));
-121
+                }
                 _ => {}
-123
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-129
+    }
-130
+}
 impl ListSpeechSynthesisTasksInput {
     /// 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 ListSpeechSynthesisTasksInput {
     /// Creates a new builder-style object to manufacture [`ListSpeechSynthesisTasksInput`](crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksInput).
     pub fn builder() -> crate::operation::list_speech_synthesis_tasks::builders::ListSpeechSynthesisTasksInputBuilder {
         crate::operation::list_speech_synthesis_tasks::builders::ListSpeechSynthesisTasksInputBuilder::default()
-146
+    }
-147
+}
-148
 /// A builder for [`ListSpeechSynthesisTasksInput`](crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ListSpeechSynthesisTasksInputBuilder {
     pub(crate) max_results: ::std::option::Option<i32>,
     pub(crate) next_token: ::std::option::Option<::std::string::String>,
     pub(crate) status: ::std::option::Option<crate::types::TaskStatus>,
-156
+}
 impl ListSpeechSynthesisTasksInputBuilder {
     /// <p>Maximum number of speech synthesis tasks returned in a List operation.</p>
     pub fn max_results(mut self, input: i32) -> Self {
         self.max_results = ::std::option::Option::Some(input);
         self
-162
+    }
     /// <p>Maximum number of speech synthesis tasks returned in a List operation.</p>
     pub fn set_max_results(mut self, input: ::std::option::Option<i32>) -> Self {
         self.max_results = input;
         self
-167
+    }
     /// <p>Maximum number of speech synthesis tasks returned in a List operation.</p>
     pub fn get_max_results(&self) -> &::std::option::Option<i32> {
         &self.max_results
-171
+    }

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

@@ -6,6 +143,195 @@

↥ Expand context

     /// <p>An opaque pagination token returned from the previous List operation in this request. If present, this indicates where to continue the listing.</p>
     pub next_token: ::std::option::Option<::std::string::String>,
     /// <p>List of SynthesisTask objects that provides information from the specified task in the list request, including output format, creation time, task status, and so on.</p>
     pub synthesis_tasks: ::std::option::Option<::std::vec::Vec<crate::types::SynthesisTask>>,
     _request_id: Option<String>,
-11
+}
 impl ListSpeechSynthesisTasksOutput {
     /// <p>An opaque pagination token returned from the previous List operation in this request. If present, this indicates where to continue the listing.</p>
     pub fn next_token(&self) -> ::std::option::Option<&str> {
         self.next_token.as_deref()
-16
+    }
     /// <p>List of SynthesisTask objects that provides information from the specified task in the list request, including output format, creation time, task status, and so on.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.synthesis_tasks.is_none()`.
     pub fn synthesis_tasks(&self) -> &[crate::types::SynthesisTask] {
         self.synthesis_tasks.as_deref().unwrap_or_default()
-22
+    }
-23
+}
 static LISTSPEECHSYNTHESISTASKSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.polly.synthetic#ListSpeechSynthesisTasksOutput",

     "com.amazonaws.polly.synthetic",
     "ListSpeechSynthesisTasksOutput",
 );
 static LISTSPEECHSYNTHESISTASKSOUTPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#ListSpeechSynthesisTasksOutput$NextToken",
         "com.amazonaws.polly.synthetic",
         "ListSpeechSynthesisTasksOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_token",
     "NextToken",
 ,
 );
 static LISTSPEECHSYNTHESISTASKSOUTPUT_MEMBER_SYNTHESIS_TASKS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#ListSpeechSynthesisTasksOutput$SynthesisTasks",
         "com.amazonaws.polly.synthetic",
         "ListSpeechSynthesisTasksOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "synthesis_tasks",
     "SynthesisTasks",
 ,
 );
 static LISTSPEECHSYNTHESISTASKSOUTPUT_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 LISTSPEECHSYNTHESISTASKSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTSPEECHSYNTHESISTASKSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTSPEECHSYNTHESISTASKSOUTPUT_MEMBER_NEXT_TOKEN,
         &LISTSPEECHSYNTHESISTASKSOUTPUT_MEMBER_SYNTHESIS_TASKS,
         &LISTSPEECHSYNTHESISTASKSOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ListSpeechSynthesisTasksOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTSPEECHSYNTHESISTASKSOUTPUT_SCHEMA;
-68
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListSpeechSynthesisTasksOutput {
     #[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.next_token {
             ser.write_string(&LISTSPEECHSYNTHESISTASKSOUTPUT_MEMBER_NEXT_TOKEN, val)?;
-77
+        }
         if let Some(ref val) = self.synthesis_tasks {
             ser.write_list(
                 &LISTSPEECHSYNTHESISTASKSOUTPUT_MEMBER_SYNTHESIS_TASKS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::SynthesisTask::SCHEMA, item)?;
-84
+                    }
                     Ok(())
                 },
             )?;
-88
+        }
         Ok(())
-90
+    }
-91
+}
 impl ListSpeechSynthesisTasksOutput {
     /// 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(&LISTSPEECHSYNTHESISTASKSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTSPEECHSYNTHESISTASKSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.next_token = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.synthesis_tasks = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::SynthesisTask::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(2) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl ListSpeechSynthesisTasksOutput {
     /// 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(&LISTSPEECHSYNTHESISTASKSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.next_token = Some(deser.read_string(member)?);
-157
+                }
                 Some(1) => {
                     builder.synthesis_tasks = 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::SynthesisTask::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::SynthesisTask::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-167
+                }
                 _ => {}
-169
+            }
             Ok(())
         })?;
         Ok(builder.build())
-173
+    }
-174
+}
 impl ::aws_types::request_id::RequestId for ListSpeechSynthesisTasksOutput {

↧ Expand context

     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-178
+    }
-179
+}
 impl ListSpeechSynthesisTasksOutput {
     /// Creates a new builder-style object to manufacture [`ListSpeechSynthesisTasksOutput`](crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksOutput).
     pub fn builder() -> crate::operation::list_speech_synthesis_tasks::builders::ListSpeechSynthesisTasksOutputBuilder {
         crate::operation::list_speech_synthesis_tasks::builders::ListSpeechSynthesisTasksOutputBuilder::default()
-184
+    }
-185
+}
-186
 /// A builder for [`ListSpeechSynthesisTasksOutput`](crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListSpeechSynthesisTasksOutputBuilder {
     pub(crate) next_token: ::std::option::Option<::std::string::String>,
     pub(crate) synthesis_tasks: ::std::option::Option<::std::vec::Vec<crate::types::SynthesisTask>>,
     _request_id: Option<String>,
-194
+}
 impl ListSpeechSynthesisTasksOutputBuilder {

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `PutLexicon`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutLexicon;
 impl PutLexicon {
     /// Creates a new `PutLexicon`
     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::put_lexicon::PutLexiconInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::put_lexicon::PutLexiconOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::put_lexicon::PutLexiconInput,
     ) -> ::std::result::Result<
         crate::operation::put_lexicon::PutLexiconOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_lexicon::PutLexiconError,
             ::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::put_lexicon::PutLexiconError>()
                     .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::put_lexicon::PutLexiconOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -115,119 +246,421 @@

↥ Expand context

         });
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutLexicon")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutLexiconEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_lexicon::PutLexiconError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_lexicon::PutLexiconError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::put_lexicon::PutLexiconError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct PutLexiconResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutLexiconResponseDeserializer {
     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 {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_put_lexicon::de_put_lexicon_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[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::put_lexicon::PutLexiconError::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 {
                 "InvalidLexiconException" => crate::operation::put_lexicon::PutLexiconError::InvalidLexiconException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidLexiconException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidLexiconException::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
                 }),
                 "LexiconSizeExceededException" => crate::operation::put_lexicon::PutLexiconError::LexiconSizeExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::LexiconSizeExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::LexiconSizeExceededException::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
                 }),
                 "MaxLexemeLengthExceededException" => crate::operation::put_lexicon::PutLexiconError::MaxLexemeLengthExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::MaxLexemeLengthExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::MaxLexemeLengthExceededException::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
                 }),
                 "MaxLexiconsNumberExceededException" => crate::operation::put_lexicon::PutLexiconError::MaxLexiconsNumberExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::MaxLexiconsNumberExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::MaxLexiconsNumberExceededException::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::put_lexicon::PutLexiconError::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
                 }),
                 "UnsupportedPlsAlphabetException" => crate::operation::put_lexicon::PutLexiconError::UnsupportedPlsAlphabetException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::UnsupportedPlsAlphabetException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::UnsupportedPlsAlphabetException::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
                 }),
                 "UnsupportedPlsLanguageException" => crate::operation::put_lexicon::PutLexiconError::UnsupportedPlsLanguageException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::UnsupportedPlsLanguageException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::UnsupportedPlsLanguageException::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::put_lexicon::PutLexiconError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_put_lexicon::de_put_lexicon_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, PutLexicon::OUTPUT_SCHEMA, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::put_lexicon::PutLexiconOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-372
+    }
-373
+}
 #[derive(Debug)]
 struct PutLexiconRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutLexiconRequestSerializer {
     #[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::put_lexicon::PutLexiconInput>().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::put_lexicon::PutLexiconInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
                 let name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "name",
                         "cannot be empty or unset",
                     ));
--
+                }
                 ::std::write!(output, "/v1/lexicons/{Name}", Name = name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_lexicon::PutLexiconInput,
                 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("PUT").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_put_lexicon::ser_put_lexicon_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, PutLexicon::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-392
+    }
-393
+}
 #[derive(Debug)]
 struct PutLexiconEndpointParamsInterceptor;
-396
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutLexiconEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutLexiconEndpointParamsInterceptor"
-400
+    }
-401

↧ 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::<PutLexiconInput>()
             .ok_or("failed to downcast to PutLexiconInput")?;
-416
         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()))

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

@@ -11,11 +139,153 @@

↥ Expand context

 impl PutLexiconInput {
     /// <p>Name of the lexicon. The name must follow the regular express format \[0-9A-Za-z\]{1,20}. That is, the name is a case-sensitive alphanumeric string up to 20 characters long.</p>
     pub fn name(&self) -> ::std::option::Option<&str> {
         self.name.as_deref()
-15
+    }
     /// <p>Content of the PLS lexicon as string data.</p>
     pub fn content(&self) -> ::std::option::Option<&str> {
         self.content.as_deref()
-19
+    }
-20
+}
 impl ::std::fmt::Debug for PutLexiconInput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("PutLexiconInput");
         formatter.field("name", &self.name);
         formatter.field("content", &"*** Sensitive Data Redacted ***");
         formatter.finish()
-27
+    }
-28
+}
 static PUTLEXICONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.polly.synthetic#PutLexiconInput",

     "com.amazonaws.polly.synthetic",
     "PutLexiconInput",
 );
 static PUTLEXICONINPUT_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#PutLexiconInput$Name",
         "com.amazonaws.polly.synthetic",
         "PutLexiconInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "name",
     "Name",
 ,
-43
+)
 .with_http_label();
 static PUTLEXICONINPUT_MEMBER_CONTENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.polly.synthetic#PutLexiconInput$Content",
         "com.amazonaws.polly.synthetic",
         "PutLexiconInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content",
     "Content",
 ,
 );
 static PUTLEXICONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTLEXICONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTLEXICONINPUT_MEMBER_NAME, &PUTLEXICONINPUT_MEMBER_CONTENT],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/v1/lexicons/{Name}", None));
 impl PutLexiconInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTLEXICONINPUT_SCHEMA;
-64
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutLexiconInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.name {
             ser.write_string(&PUTLEXICONINPUT_MEMBER_NAME, val)?;
-73
+        }
         if let Some(ref val) = self.content {
             ser.write_string(&PUTLEXICONINPUT_MEMBER_CONTENT, val)?;
-76
+        }
         Ok(())
-78
+    }
-79
+}
 impl PutLexiconInput {
     /// 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(&PUTLEXICONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTLEXICONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.name = Some(deser.read_string(member)?);
-98
+                }
                 Some(1) => {
                     builder.content = Some(deser.read_string(member)?);
-101
+                }
                 _ => {}
-103
+            }
             Ok(())
         })?;
         builder.name = builder.name.or(Some(String::new()));
         builder.content = builder.content.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-111
+    }
-112
+}
 impl PutLexiconInput {
     /// 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 PutLexiconInput {
     /// Creates a new builder-style object to manufacture [`PutLexiconInput`](crate::operation::put_lexicon::PutLexiconInput).
     pub fn builder() -> crate::operation::put_lexicon::builders::PutLexiconInputBuilder {
         crate::operation::put_lexicon::builders::PutLexiconInputBuilder::default()
-128
+    }
-129
+}
-130
 /// A builder for [`PutLexiconInput`](crate::operation::put_lexicon::PutLexiconInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct PutLexiconInputBuilder {
     pub(crate) name: ::std::option::Option<::std::string::String>,
     pub(crate) content: ::std::option::Option<::std::string::String>,
-137
+}
 impl PutLexiconInputBuilder {
     /// <p>Name of the lexicon. The name must follow the regular express format \[0-9A-Za-z\]{1,20}. That is, the name is a case-sensitive alphanumeric string up to 20 characters long.</p>
     /// This field is required.
     pub fn name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.name = ::std::option::Option::Some(input.into());
         self
-144
+    }
     /// <p>Name of the lexicon. The name must follow the regular express format \[0-9A-Za-z\]{1,20}. That is, the name is a case-sensitive alphanumeric string up to 20 characters long.</p>
     pub fn set_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.name = input;
         self
-149
+    }
     /// <p>Name of the lexicon. The name must follow the regular express format \[0-9A-Za-z\]{1,20}. That is, the name is a case-sensitive alphanumeric string up to 20 characters long.</p>
     pub fn get_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.name
-153
+    }

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

@@ -1,1 +80,111 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct PutLexiconOutput {
     _request_id: Option<String>,
-7
+}
 static PUTLEXICONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.polly.synthetic#PutLexiconOutput",
     "com.amazonaws.polly.synthetic",
     "PutLexiconOutput",
 );
 static PUTLEXICONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(PUTLEXICONOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static PUTLEXICONOUTPUT_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 PUTLEXICONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTLEXICONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTLEXICONOUTPUT_MEMBER__REQUEST_ID],
 );
 impl PutLexiconOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTLEXICONOUTPUT_SCHEMA;
-28
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutLexiconOutput {
     #[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> {
         Ok(())
-36
+    }
-37
+}
 impl PutLexiconOutput {
     /// 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(&PUTLEXICONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTLEXICONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-58
+            }
             Ok(())
         })?;
         Ok(builder.build())
-62
+    }
-63
+}
 impl PutLexiconOutput {
     /// 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());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl ::aws_types::request_id::RequestId for PutLexiconOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-85
+    }
-86
+}
 impl PutLexiconOutput {
     /// Creates a new builder-style object to manufacture [`PutLexiconOutput`](crate::operation::put_lexicon::PutLexiconOutput).
     pub fn builder() -> crate::operation::put_lexicon::builders::PutLexiconOutputBuilder {
         crate::operation::put_lexicon::builders::PutLexiconOutputBuilder::default()
-91
+    }

↧ Expand context

-92
+}
-93
 /// A builder for [`PutLexiconOutput`](crate::operation::put_lexicon::PutLexiconOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutLexiconOutputBuilder {
     _request_id: Option<String>,
-99
+}
 impl PutLexiconOutputBuilder {
     pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         self._request_id = Some(request_id.into());
         self
-104
+    }
-105
     pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         self._request_id = request_id;
         self
-109
+    }
     /// Consumes the builder and constructs a [`PutLexiconOutput`](crate::operation::put_lexicon::PutLexiconOutput).
     pub fn build(self) -> crate::operation::put_lexicon::PutLexiconOutput {

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

@@ -1,1 +40,46 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `StartSpeechSynthesisTask`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartSpeechSynthesisTask;
 impl StartSpeechSynthesisTask {
     /// Creates a new `StartSpeechSynthesisTask`
     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::start_speech_synthesis_task::StartSpeechSynthesisTaskInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskInput,
     ) -> ::std::result::Result<
         crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError,
             ::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::start_speech_synthesis_task::StartSpeechSynthesisTaskError>()
                     .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::start_speech_synthesis_task::StartSpeechSynthesisTaskOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -118,124 +242,570 @@

↥ Expand context

         });
-125
         ::std::option::Option::Some(cfg.freeze())
-127
+    }
-128
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("StartSpeechSynthesisTask")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(StartSpeechSynthesisTaskEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError,
             >::new());
-146
         ::std::borrow::Cow::Owned(rcb)
-148
+    }
-149
+}
-150
 #[derive(Debug)]
 struct StartSpeechSynthesisTaskResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StartSpeechSynthesisTaskResponseDeserializer {
     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 {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_start_speech_synthesis_task::de_start_speech_synthesis_task_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[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::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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
                     })
-+
+                }
                 "InvalidS3BucketException" => {
                     crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::InvalidS3BucketException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InvalidS3BucketException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InvalidS3BucketException::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
                     })
-+
+                }
                 "InvalidS3KeyException" => crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::InvalidS3KeyException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidS3KeyException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidS3KeyException::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::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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
                     })
-+
+                }
                 "InvalidSnsTopicArnException" => {
                     crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskError::InvalidSnsTopicArnException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InvalidSnsTopicArnException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InvalidSnsTopicArnException::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::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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::start_speech_synthesis_task::StartSpeechSynthesisTaskError::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::start_speech_synthesis_task::StartSpeechSynthesisTaskError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_start_speech_synthesis_task::de_start_speech_synthesis_task_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, StartSpeechSynthesisTask::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-519
+    }
-520
+}
 #[derive(Debug)]
 struct StartSpeechSynthesisTaskRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StartSpeechSynthesisTaskRequestSerializer {
     #[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::start_speech_synthesis_task::StartSpeechSynthesisTaskInput>()
             .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::start_speech_synthesis_task::StartSpeechSynthesisTaskInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v1/synthesisTasks").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskInput,
                 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_start_speech_synthesis_task::ser_start_speech_synthesis_task_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, StartSpeechSynthesisTask::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-541
+    }
-542
+}
 #[derive(Debug)]
 struct StartSpeechSynthesisTaskEndpointParamsInterceptor;
-545
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartSpeechSynthesisTaskEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartSpeechSynthesisTaskEndpointParamsInterceptor"
-549
+    }
-550

↧ 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::<StartSpeechSynthesisTaskInput>()
             .ok_or("failed to downcast to StartSpeechSynthesisTaskInput")?;
-565
         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()))

1 1	`// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.`
2 2	`#[allow(missing_docs)] // documentation missing in model`

AWS SDK

Files changed: