AWS SDK

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/execute_command/_execute_command_output.rs

@@ -28,28 +199,259 @@

-28
+    }
     /// <p>The name of the container.</p>
     pub fn container_name(&self) -> ::std::option::Option<&str> {
         self.container_name.as_deref()
-32
+    }
     /// <p>Determines whether the execute command session is running in interactive mode. Amazon ECS only supports initiating interactive sessions, so you must specify <code>true</code> for this value.</p>
     pub fn interactive(&self) -> bool {
         self.interactive
-36
+    }
     /// <p>The details of the SSM session that was created for this instance of execute-command.</p>
     pub fn session(&self) -> ::std::option::Option<&crate::types::Session> {
         self.session.as_ref()
-40
+    }
     /// <p>The Amazon Resource Name (ARN) of the task.</p>
     pub fn task_arn(&self) -> ::std::option::Option<&str> {
         self.task_arn.as_deref()
-44
+    }
-45
+}
 static EXECUTECOMMANDOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs.synthetic#ExecuteCommandOutput",

     "com.amazonaws.ecs.synthetic",
     "ExecuteCommandOutput",
 );
 static EXECUTECOMMANDOUTPUT_MEMBER_CLUSTER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ExecuteCommandOutput$clusterArn",
         "com.amazonaws.ecs.synthetic",
         "ExecuteCommandOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "cluster_arn",
     "clusterArn",
 ,
 );
 static EXECUTECOMMANDOUTPUT_MEMBER_CONTAINER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ExecuteCommandOutput$containerArn",
         "com.amazonaws.ecs.synthetic",
         "ExecuteCommandOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "container_arn",
     "containerArn",
 ,
 );
 static EXECUTECOMMANDOUTPUT_MEMBER_CONTAINER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ExecuteCommandOutput$containerName",
         "com.amazonaws.ecs.synthetic",
         "ExecuteCommandOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "container_name",
     "containerName",
 ,
 );
 static EXECUTECOMMANDOUTPUT_MEMBER_INTERACTIVE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ExecuteCommandOutput$interactive",
         "com.amazonaws.ecs.synthetic",
         "ExecuteCommandOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "interactive",
 ,
 );
 static EXECUTECOMMANDOUTPUT_MEMBER_SESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ExecuteCommandOutput$session",
         "com.amazonaws.ecs.synthetic",
         "ExecuteCommandOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "session",
 ,
 );
 static EXECUTECOMMANDOUTPUT_MEMBER_TASK_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ExecuteCommandOutput$taskArn",
         "com.amazonaws.ecs.synthetic",
         "ExecuteCommandOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "task_arn",
     "taskArn",
 ,
 );
 static EXECUTECOMMANDOUTPUT_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 EXECUTECOMMANDOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EXECUTECOMMANDOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &EXECUTECOMMANDOUTPUT_MEMBER_CLUSTER_ARN,
         &EXECUTECOMMANDOUTPUT_MEMBER_CONTAINER_ARN,
         &EXECUTECOMMANDOUTPUT_MEMBER_CONTAINER_NAME,
         &EXECUTECOMMANDOUTPUT_MEMBER_INTERACTIVE,
         &EXECUTECOMMANDOUTPUT_MEMBER_SESSION,
         &EXECUTECOMMANDOUTPUT_MEMBER_TASK_ARN,
         &EXECUTECOMMANDOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ExecuteCommandOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXECUTECOMMANDOUTPUT_SCHEMA;
-134
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ExecuteCommandOutput {
     #[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.cluster_arn {
             ser.write_string(&EXECUTECOMMANDOUTPUT_MEMBER_CLUSTER_ARN, val)?;
-143
+        }
         if let Some(ref val) = self.container_arn {
             ser.write_string(&EXECUTECOMMANDOUTPUT_MEMBER_CONTAINER_ARN, val)?;
-146
+        }
         if let Some(ref val) = self.container_name {
             ser.write_string(&EXECUTECOMMANDOUTPUT_MEMBER_CONTAINER_NAME, val)?;
-149
+        }
-150
+        {
             let val = &self.interactive;
             ser.write_boolean(&EXECUTECOMMANDOUTPUT_MEMBER_INTERACTIVE, *val)?;
-153
+        }
         if let Some(ref val) = self.session {
             ser.write_struct(&EXECUTECOMMANDOUTPUT_MEMBER_SESSION, val)?;
-156
+        }
         if let Some(ref val) = self.task_arn {
             ser.write_string(&EXECUTECOMMANDOUTPUT_MEMBER_TASK_ARN, val)?;
-159
+        }
         Ok(())
-161
+    }
-162
+}
 impl ExecuteCommandOutput {
     /// 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(&EXECUTECOMMANDOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cluster_arn = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.container_arn = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder.container_name = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => {
                     builder.interactive = Some(deser.read_boolean(member)?);
-+
+                }
                 Some(4) => {
                     builder.session = Some(crate::types::Session::deserialize(deser)?);
-+
+                }
                 Some(5) => {
                     builder.task_arn = Some(deser.read_string(member)?);
-+
+                }
                 Some(6) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl ExecuteCommandOutput {
     /// 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(&EXECUTECOMMANDOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EXECUTECOMMANDOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cluster_arn = Some(deser.read_string(member)?);
-233
+                }
                 Some(1) => {
                     builder.container_arn = Some(deser.read_string(member)?);
-236
+                }
                 Some(2) => {
                     builder.container_name = Some(deser.read_string(member)?);
-239
+                }

↧ Expand context

                 Some(3) => {
                     builder.interactive = Some(deser.read_boolean(member)?);
-242
+                }
                 Some(4) => {
                     builder.session = Some(crate::types::Session::deserialize(deser)?);
-245
+                }
                 Some(5) => {
                     builder.task_arn = Some(deser.read_string(member)?);
-248
+                }
                 _ => {}
-250
+            }
             Ok(())
         })?;
         Ok(builder.build())
-254
+    }
-255
+}
 impl ::aws_types::request_id::RequestId for ExecuteCommandOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-259
+    }

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/get_task_protection.rs

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

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

@@ -115,119 +242,427 @@

↥ 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("GetTaskProtection")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetTaskProtectionEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_task_protection::GetTaskProtectionError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_task_protection::GetTaskProtectionError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::get_task_protection::GetTaskProtectionError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct GetTaskProtectionResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetTaskProtectionResponseDeserializer {
     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_get_task_protection::de_get_task_protection_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::get_task_protection::GetTaskProtectionError::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 {
                 "AccessDeniedException" => crate::operation::get_task_protection::GetTaskProtectionError::AccessDeniedException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::AccessDeniedException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::AccessDeniedException::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
                 }),
                 "ClientException" => crate::operation::get_task_protection::GetTaskProtectionError::ClientException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ClientException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ClientException::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
                 }),
                 "ClusterNotFoundException" => crate::operation::get_task_protection::GetTaskProtectionError::ClusterNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ClusterNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ClusterNotFoundException::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
                 }),
                 "InvalidParameterException" => crate::operation::get_task_protection::GetTaskProtectionError::InvalidParameterException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidParameterException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidParameterException::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
                 }),
                 "ResourceNotFoundException" => crate::operation::get_task_protection::GetTaskProtectionError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::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
                 }),
                 "ServerException" => crate::operation::get_task_protection::GetTaskProtectionError::ServerException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServerException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServerException::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
                 }),
                 "UnsupportedFeatureException" => crate::operation::get_task_protection::GetTaskProtectionError::UnsupportedFeatureException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::UnsupportedFeatureException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::UnsupportedFeatureException::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::get_task_protection::GetTaskProtectionError::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_get_task_protection::de_get_task_protection_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, GetTaskProtection::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::get_task_protection::GetTaskProtectionOutput::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))
-+
+        }
-376
+    }
-377
+}
 #[derive(Debug)]
 struct GetTaskProtectionRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetTaskProtectionRequestSerializer {
     #[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::get_task_protection::GetTaskProtectionInput>()
             .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::get_task_protection::GetTaskProtectionInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_task_protection::GetTaskProtectionInput,
                 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/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "AmazonEC2ContainerServiceV20141113.GetTaskProtection",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_get_task_protection::ser_get_task_protection_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, GetTaskProtection::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-398
+    }
-399
+}
 #[derive(Debug)]
 struct GetTaskProtectionEndpointParamsInterceptor;
-402
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetTaskProtectionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetTaskProtectionEndpointParamsInterceptor"
-406
+    }
-407

↧ 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::<GetTaskProtectionInput>()
             .ok_or("failed to downcast to GetTaskProtectionInput")?;
-422
         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/ecs/src/operation/get_task_protection/_get_task_protection_input.rs

@@ -52,52 +150,152 @@

↥ Expand context

 );
 impl GetTaskProtectionInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETTASKPROTECTIONINPUT_SCHEMA;
-56
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetTaskProtectionInput {
     #[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.cluster {
             ser.write_string(&GETTASKPROTECTIONINPUT_MEMBER_CLUSTER, val)?;
-65
+        }
         if let Some(ref val) = self.tasks {
             ser.write_list(
                 &GETTASKPROTECTIONINPUT_MEMBER_TASKS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;

-72
+                    }
                     Ok(())
                 },
             )?;
-76
+        }
         Ok(())
-78
+    }
-79
+}
 impl GetTaskProtectionInput {
     /// 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(&GETTASKPROTECTIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETTASKPROTECTIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cluster = Some(deser.read_string(member)?);
-98
+                }
                 Some(1) => {
                     builder.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(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.tasks = Some(deser.read_string_list(member)?);
-101
+                }
                 _ => {}
-103
+            }
             Ok(())
         })?;
         builder.cluster = builder.cluster.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-110
+    }
-111
+}
 impl GetTaskProtectionInput {
     /// 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 GetTaskProtectionInput {
     /// Creates a new builder-style object to manufacture [`GetTaskProtectionInput`](crate::operation::get_task_protection::GetTaskProtectionInput).
     pub fn builder() -> crate::operation::get_task_protection::builders::GetTaskProtectionInputBuilder {
         crate::operation::get_task_protection::builders::GetTaskProtectionInputBuilder::default()
-127
+    }
-128
+}
-129
 /// A builder for [`GetTaskProtectionInput`](crate::operation::get_task_protection::GetTaskProtectionInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GetTaskProtectionInputBuilder {
     pub(crate) cluster: ::std::option::Option<::std::string::String>,
     pub(crate) tasks: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-136
+}
 impl GetTaskProtectionInputBuilder {
     /// <p>The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service that the task sets exist in.</p>
     /// This field is required.
     pub fn cluster(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.cluster = ::std::option::Option::Some(input.into());
         self
-143
+    }
     /// <p>The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service that the task sets exist in.</p>
     pub fn set_cluster(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.cluster = input;
         self
-148
+    }
     /// <p>The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service that the task sets exist in.</p>
     pub fn get_cluster(&self) -> &::std::option::Option<::std::string::String> {
         &self.cluster
-152
+    }

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/get_task_protection/_get_task_protection_output.rs

@@ -24,24 +176,235 @@

↥ Expand context

     /// <p><code>taskArn</code>: The task ARN.</p></li>
     /// <li>
     /// <p><code>protectionEnabled</code>: The protection status of the task. If scale-in protection is turned on for a task, the value is <code>true</code>. Otherwise, it is <code>false</code>.</p></li>
     /// <li>
     /// <p><code>expirationDate</code>: The epoch time when protection for the task will expire.</p></li>
     /// </ul>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.protected_tasks.is_none()`.
     pub fn protected_tasks(&self) -> &[crate::types::ProtectedTask] {
         self.protected_tasks.as_deref().unwrap_or_default()
-34
+    }
     /// <p>Any failures associated with the call.</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 `.failures.is_none()`.
     pub fn failures(&self) -> &[crate::types::Failure] {
         self.failures.as_deref().unwrap_or_default()
-40
+    }
-41
+}
 static GETTASKPROTECTIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs.synthetic#GetTaskProtectionOutput",

     "com.amazonaws.ecs.synthetic",
     "GetTaskProtectionOutput",
 );
 static GETTASKPROTECTIONOUTPUT_MEMBER_PROTECTED_TASKS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#GetTaskProtectionOutput$protectedTasks",
         "com.amazonaws.ecs.synthetic",
         "GetTaskProtectionOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "protected_tasks",
     "protectedTasks",
 ,
 );
 static GETTASKPROTECTIONOUTPUT_MEMBER_FAILURES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#GetTaskProtectionOutput$failures",
         "com.amazonaws.ecs.synthetic",
         "GetTaskProtectionOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "failures",
 ,
 );
 static GETTASKPROTECTIONOUTPUT_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 GETTASKPROTECTIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETTASKPROTECTIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GETTASKPROTECTIONOUTPUT_MEMBER_PROTECTED_TASKS, &GETTASKPROTECTIONOUTPUT_MEMBER_FAILURES],
     &[
         &GETTASKPROTECTIONOUTPUT_MEMBER_PROTECTED_TASKS,
         &GETTASKPROTECTIONOUTPUT_MEMBER_FAILURES,
         &GETTASKPROTECTIONOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl GetTaskProtectionOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETTASKPROTECTIONOUTPUT_SCHEMA;
-86
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetTaskProtectionOutput {
     #[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.protected_tasks {
             ser.write_list(
                 &GETTASKPROTECTIONOUTPUT_MEMBER_PROTECTED_TASKS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::ProtectedTask::SCHEMA, item)?;
-99
+                    }
                     Ok(())
                 },
             )?;
-103
+        }
         if let Some(ref val) = self.failures {
             ser.write_list(
                 &GETTASKPROTECTIONOUTPUT_MEMBER_FAILURES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Failure::SCHEMA, item)?;
-110
+                    }
                     Ok(())
                 },
             )?;
-114
+        }
         Ok(())
-116
+    }
-117
+}
 impl GetTaskProtectionOutput {
     /// 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(&GETTASKPROTECTIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETTASKPROTECTIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.protected_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::ProtectedTask::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ProtectedTask::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-143
+                }
                 Some(1) => {
                     builder.failures = 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::Failure::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Failure::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(2) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl GetTaskProtectionOutput {
     /// 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(&GETTASKPROTECTIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.protected_tasks = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ProtectedTask::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(1) => {
                     builder.failures = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Failure::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-207
+                }
                 _ => {}
-209
+            }
             Ok(())
         })?;
         Ok(builder.build())
-213
+    }
-214
+}
 impl ::aws_types::request_id::RequestId for GetTaskProtectionOutput {

↧ Expand context

     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-218
+    }
-219
+}
 impl GetTaskProtectionOutput {
     /// Creates a new builder-style object to manufacture [`GetTaskProtectionOutput`](crate::operation::get_task_protection::GetTaskProtectionOutput).
     pub fn builder() -> crate::operation::get_task_protection::builders::GetTaskProtectionOutputBuilder {
         crate::operation::get_task_protection::builders::GetTaskProtectionOutputBuilder::default()
-224
+    }
-225
+}
-226
 /// A builder for [`GetTaskProtectionOutput`](crate::operation::get_task_protection::GetTaskProtectionOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetTaskProtectionOutputBuilder {
     pub(crate) protected_tasks: ::std::option::Option<::std::vec::Vec<crate::types::ProtectedTask>>,
     pub(crate) failures: ::std::option::Option<::std::vec::Vec<crate::types::Failure>>,
     _request_id: Option<String>,
-234
+}
 impl GetTaskProtectionOutputBuilder {

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/list_account_settings.rs

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

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

@@ -118,122 +247,334 @@

↥ Expand context

         });
-123
         ::std::option::Option::Some(cfg.freeze())
-125
+    }
-126
     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("ListAccountSettings")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListAccountSettingsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_account_settings::ListAccountSettingsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_account_settings::ListAccountSettingsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::list_account_settings::ListAccountSettingsError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct ListAccountSettingsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListAccountSettingsResponseDeserializer {
     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_account_settings::de_list_account_settings_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_account_settings::ListAccountSettingsError::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 {
                 "ClientException" => crate::operation::list_account_settings::ListAccountSettingsError::ClientException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ClientException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ClientException::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
                 }),
                 "InvalidParameterException" => crate::operation::list_account_settings::ListAccountSettingsError::InvalidParameterException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidParameterException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidParameterException::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
                 }),
                 "ServerException" => crate::operation::list_account_settings::ListAccountSettingsError::ServerException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServerException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServerException::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_account_settings::ListAccountSettingsError::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_account_settings::de_list_account_settings_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, ListAccountSettings::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_account_settings::ListAccountSettingsOutput::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))
-+
+        }
-283
+    }
-284
+}
 #[derive(Debug)]
 struct ListAccountSettingsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListAccountSettingsRequestSerializer {
     #[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_account_settings::ListAccountSettingsInput>()
             .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_account_settings::ListAccountSettingsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_account_settings::ListAccountSettingsInput,
                 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/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "AmazonEC2ContainerServiceV20141113.ListAccountSettings",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_list_account_settings::ser_list_account_settings_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, ListAccountSettings::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-305
+    }
-306
+}
 #[derive(Debug)]
 struct ListAccountSettingsEndpointParamsInterceptor;
-309
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListAccountSettingsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListAccountSettingsEndpointParamsInterceptor"
-313
+    }
-314

↧ 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::<ListAccountSettingsInput>()
             .ok_or("failed to downcast to ListAccountSettingsInput")?;
-329
         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/ecs/src/operation/list_account_settings/_list_account_settings_input.rs

@@ -57,57 +235,246 @@

↥ Expand context

     "com.amazonaws.ecs.synthetic",
     "ListAccountSettingsInput",
 );
 static LISTACCOUNTSETTINGSINPUT_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAccountSettingsInput$name",
         "com.amazonaws.ecs.synthetic",
         "ListAccountSettingsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "name",
 ,
 );
 static LISTACCOUNTSETTINGSINPUT_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAccountSettingsInput$value",
         "com.amazonaws.ecs.synthetic",
         "ListAccountSettingsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,

     "value",
 ,
 );
 static LISTACCOUNTSETTINGSINPUT_MEMBER_PRINCIPAL_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAccountSettingsInput$principalArn",
         "com.amazonaws.ecs.synthetic",
         "ListAccountSettingsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "principal_arn",
     "principalArn",
 ,
 );
 static LISTACCOUNTSETTINGSINPUT_MEMBER_EFFECTIVE_SETTINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAccountSettingsInput$effectiveSettings",
         "com.amazonaws.ecs.synthetic",
         "ListAccountSettingsInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "effective_settings",
     "effectiveSettings",
 ,
 );
 static LISTACCOUNTSETTINGSINPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAccountSettingsInput$nextToken",
         "com.amazonaws.ecs.synthetic",
         "ListAccountSettingsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_token",
     "nextToken",
 ,
 );
 static LISTACCOUNTSETTINGSINPUT_MEMBER_MAX_RESULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAccountSettingsInput$maxResults",
         "com.amazonaws.ecs.synthetic",
         "ListAccountSettingsInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_results",
     "maxResults",
 ,
 );
 static LISTACCOUNTSETTINGSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTACCOUNTSETTINGSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTACCOUNTSETTINGSINPUT_MEMBER_NAME,
         &LISTACCOUNTSETTINGSINPUT_MEMBER_VALUE,
         &LISTACCOUNTSETTINGSINPUT_MEMBER_PRINCIPAL_ARN,
         &LISTACCOUNTSETTINGSINPUT_MEMBER_EFFECTIVE_SETTINGS,
         &LISTACCOUNTSETTINGSINPUT_MEMBER_NEXT_TOKEN,
         &LISTACCOUNTSETTINGSINPUT_MEMBER_MAX_RESULTS,
     ],
 );
 impl ListAccountSettingsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTACCOUNTSETTINGSINPUT_SCHEMA;
-135
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListAccountSettingsInput {
     #[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(&LISTACCOUNTSETTINGSINPUT_MEMBER_NAME, val.as_str())?;
-144
+        }
         if let Some(ref val) = self.value {
             ser.write_string(&LISTACCOUNTSETTINGSINPUT_MEMBER_VALUE, val)?;
-147
+        }
         if let Some(ref val) = self.principal_arn {
             ser.write_string(&LISTACCOUNTSETTINGSINPUT_MEMBER_PRINCIPAL_ARN, val)?;
-150
+        }
         if let Some(ref val) = self.effective_settings {
             ser.write_boolean(&LISTACCOUNTSETTINGSINPUT_MEMBER_EFFECTIVE_SETTINGS, *val)?;
-153
+        }
         if let Some(ref val) = self.next_token {
             ser.write_string(&LISTACCOUNTSETTINGSINPUT_MEMBER_NEXT_TOKEN, val)?;
-156
+        }
         if let Some(ref val) = self.max_results {
             ser.write_integer(&LISTACCOUNTSETTINGSINPUT_MEMBER_MAX_RESULTS, *val)?;
-159
+        }
         Ok(())
-161
+    }
-162
+}
 impl ListAccountSettingsInput {
     /// 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(&LISTACCOUNTSETTINGSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTACCOUNTSETTINGSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.name = Some(crate::types::SettingName::from(deser.read_string(member)?.as_str()));
-181
+                }
                 Some(1) => {
                     builder.value = Some(deser.read_string(member)?);
-184
+                }
                 Some(2) => {
                     builder.principal_arn = Some(deser.read_string(member)?);
-187
+                }
                 Some(3) => {
                     builder.effective_settings = Some(deser.read_boolean(member)?);
-190
+                }
                 Some(4) => {
                     builder.next_token = Some(deser.read_string(member)?);
-193
+                }
                 Some(5) => {
                     builder.max_results = Some(deser.read_integer(member)?);
-196
+                }
                 _ => {}
-198
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-204
+    }
-205
+}
 impl ListAccountSettingsInput {
     /// 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 ListAccountSettingsInput {
     /// Creates a new builder-style object to manufacture [`ListAccountSettingsInput`](crate::operation::list_account_settings::ListAccountSettingsInput).
     pub fn builder() -> crate::operation::list_account_settings::builders::ListAccountSettingsInputBuilder {
         crate::operation::list_account_settings::builders::ListAccountSettingsInputBuilder::default()
-221
+    }
-222
+}
-223
 /// A builder for [`ListAccountSettingsInput`](crate::operation::list_account_settings::ListAccountSettingsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ListAccountSettingsInputBuilder {
     pub(crate) name: ::std::option::Option<crate::types::SettingName>,
     pub(crate) value: ::std::option::Option<::std::string::String>,
     pub(crate) principal_arn: ::std::option::Option<::std::string::String>,
     pub(crate) effective_settings: ::std::option::Option<bool>,
     pub(crate) next_token: ::std::option::Option<::std::string::String>,
     pub(crate) max_results: ::std::option::Option<i32>,
-234
+}
 impl ListAccountSettingsInputBuilder {
     /// <p>The name of the account setting you want to list the settings for.</p>
     pub fn name(mut self, input: crate::types::SettingName) -> Self {
         self.name = ::std::option::Option::Some(input);
         self
-240
+    }
     /// <p>The name of the account setting you want to list the settings for.</p>
     pub fn set_name(mut self, input: ::std::option::Option<crate::types::SettingName>) -> Self {
         self.name = input;
         self
-245
+    }
     /// <p>The name of the account setting you want to list the settings for.</p>

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/list_account_settings/_list_account_settings_output.rs

@@ -16,16 +137,192 @@

↥ Expand context

     pub fn settings(&self) -> &[crate::types::Setting] {
         self.settings.as_deref().unwrap_or_default()
-18
+    }
     /// <p>The <code>nextToken</code> value to include in a future <code>ListAccountSettings</code> request. When the results of a <code>ListAccountSettings</code> request exceed <code>maxResults</code>, this value can be used to retrieve the next page of results. This value is <code>null</code> when there are no more results to return.</p>
     pub fn next_token(&self) -> ::std::option::Option<&str> {
         self.next_token.as_deref()
-22
+    }
-23
+}
 static LISTACCOUNTSETTINGSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs.synthetic#ListAccountSettingsOutput",
     "com.amazonaws.ecs.synthetic",
     "ListAccountSettingsOutput",
 );
 static LISTACCOUNTSETTINGSOUTPUT_MEMBER_SETTINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAccountSettingsOutput$settings",
         "com.amazonaws.ecs.synthetic",
         "ListAccountSettingsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,

     "settings",
 ,
 );
 static LISTACCOUNTSETTINGSOUTPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAccountSettingsOutput$nextToken",
         "com.amazonaws.ecs.synthetic",
         "ListAccountSettingsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_token",
     "nextToken",
 ,
 );
 static LISTACCOUNTSETTINGSOUTPUT_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 LISTACCOUNTSETTINGSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTACCOUNTSETTINGSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&LISTACCOUNTSETTINGSOUTPUT_MEMBER_SETTINGS, &LISTACCOUNTSETTINGSOUTPUT_MEMBER_NEXT_TOKEN],
     &[
         &LISTACCOUNTSETTINGSOUTPUT_MEMBER_SETTINGS,
         &LISTACCOUNTSETTINGSOUTPUT_MEMBER_NEXT_TOKEN,
         &LISTACCOUNTSETTINGSOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ListAccountSettingsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTACCOUNTSETTINGSOUTPUT_SCHEMA;
-68
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListAccountSettingsOutput {
     #[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.settings {
             ser.write_list(
                 &LISTACCOUNTSETTINGSOUTPUT_MEMBER_SETTINGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Setting::SCHEMA, item)?;
-81
+                    }
                     Ok(())
                 },
             )?;
-85
+        }
         if let Some(ref val) = self.next_token {
             ser.write_string(&LISTACCOUNTSETTINGSOUTPUT_MEMBER_NEXT_TOKEN, val)?;
-88
+        }
         Ok(())
-90
+    }
-91
+}
 impl ListAccountSettingsOutput {
     /// 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(&LISTACCOUNTSETTINGSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTACCOUNTSETTINGSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.settings = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Setting::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 ListAccountSettingsOutput {
     /// 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(&LISTACCOUNTSETTINGSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.settings = 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::Setting::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Setting::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 ListAccountSettingsOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-178
+    }
-179
+}
 impl ListAccountSettingsOutput {
     /// Creates a new builder-style object to manufacture [`ListAccountSettingsOutput`](crate::operation::list_account_settings::ListAccountSettingsOutput).
     pub fn builder() -> crate::operation::list_account_settings::builders::ListAccountSettingsOutputBuilder {
         crate::operation::list_account_settings::builders::ListAccountSettingsOutputBuilder::default()
-184
+    }
-185
+}
-186
 /// A builder for [`ListAccountSettingsOutput`](crate::operation::list_account_settings::ListAccountSettingsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListAccountSettingsOutputBuilder {
     pub(crate) settings: ::std::option::Option<::std::vec::Vec<crate::types::Setting>>,
     pub(crate) next_token: ::std::option::Option<::std::string::String>,

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/list_attributes.rs

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

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

@@ -115,119 +242,307 @@

↥ 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("ListAttributes")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListAttributesEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_attributes::ListAttributesError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_attributes::ListAttributesError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::list_attributes::ListAttributesError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct ListAttributesResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListAttributesResponseDeserializer {
     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_attributes::de_list_attributes_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_attributes::ListAttributesError::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 {
                 "ClusterNotFoundException" => crate::operation::list_attributes::ListAttributesError::ClusterNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ClusterNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ClusterNotFoundException::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
                 }),
                 "InvalidParameterException" => crate::operation::list_attributes::ListAttributesError::InvalidParameterException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidParameterException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidParameterException::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_attributes::ListAttributesError::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_attributes::de_list_attributes_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, ListAttributes::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_attributes::ListAttributesOutput::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))
-+
+        }
-256
+    }
-257
+}
 #[derive(Debug)]
 struct ListAttributesRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListAttributesRequestSerializer {
     #[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_attributes::ListAttributesInput>()
             .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_attributes::ListAttributesInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_attributes::ListAttributesInput,
                 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/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "AmazonEC2ContainerServiceV20141113.ListAttributes",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_list_attributes::ser_list_attributes_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, ListAttributes::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-278
+    }
-279
+}
 #[derive(Debug)]
 struct ListAttributesEndpointParamsInterceptor;
-282
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListAttributesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListAttributesEndpointParamsInterceptor"
-286
+    }
-287

↧ 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::<ListAttributesInput>()
             .ok_or("failed to downcast to ListAttributesInput")?;
-302
         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/ecs/src/operation/list_attributes/_list_attributes_input.rs

@@ -41,41 +229,240 @@

↥ Expand context

     pub fn next_token(&self) -> ::std::option::Option<&str> {
         self.next_token.as_deref()
-43
+    }
     /// <p>The maximum number of cluster results that <code>ListAttributes</code> returned in paginated output. When this parameter is used, <code>ListAttributes</code> only returns <code>maxResults</code> results in a single page along with a <code>nextToken</code> response element. The remaining results of the initial request can be seen by sending another <code>ListAttributes</code> request with the returned <code>nextToken</code> value. This value can be between 1 and 100. If this parameter isn't used, then <code>ListAttributes</code> returns up to 100 results and a <code>nextToken</code> value if applicable.</p>
     pub fn max_results(&self) -> ::std::option::Option<i32> {
         self.max_results
-47
+    }
-48
+}
 static LISTATTRIBUTESINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs.synthetic#ListAttributesInput",
     "com.amazonaws.ecs.synthetic",
     "ListAttributesInput",
 );
 static LISTATTRIBUTESINPUT_MEMBER_CLUSTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAttributesInput$cluster",
         "com.amazonaws.ecs.synthetic",
         "ListAttributesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,

     "cluster",
 ,
 );
 static LISTATTRIBUTESINPUT_MEMBER_TARGET_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAttributesInput$targetType",
         "com.amazonaws.ecs.synthetic",
         "ListAttributesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "target_type",
     "targetType",
 ,
 );
 static LISTATTRIBUTESINPUT_MEMBER_ATTRIBUTE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAttributesInput$attributeName",
         "com.amazonaws.ecs.synthetic",
         "ListAttributesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "attribute_name",
     "attributeName",
 ,
 );
 static LISTATTRIBUTESINPUT_MEMBER_ATTRIBUTE_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAttributesInput$attributeValue",
         "com.amazonaws.ecs.synthetic",
         "ListAttributesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "attribute_value",
     "attributeValue",
 ,
 );
 static LISTATTRIBUTESINPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAttributesInput$nextToken",
         "com.amazonaws.ecs.synthetic",
         "ListAttributesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_token",
     "nextToken",
 ,
 );
 static LISTATTRIBUTESINPUT_MEMBER_MAX_RESULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAttributesInput$maxResults",
         "com.amazonaws.ecs.synthetic",
         "ListAttributesInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_results",
     "maxResults",
 ,
 );
 static LISTATTRIBUTESINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTATTRIBUTESINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTATTRIBUTESINPUT_MEMBER_CLUSTER,
         &LISTATTRIBUTESINPUT_MEMBER_TARGET_TYPE,
         &LISTATTRIBUTESINPUT_MEMBER_ATTRIBUTE_NAME,
         &LISTATTRIBUTESINPUT_MEMBER_ATTRIBUTE_VALUE,
         &LISTATTRIBUTESINPUT_MEMBER_NEXT_TOKEN,
         &LISTATTRIBUTESINPUT_MEMBER_MAX_RESULTS,
     ],
 );
 impl ListAttributesInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTATTRIBUTESINPUT_SCHEMA;
-129
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListAttributesInput {
     #[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.cluster {
             ser.write_string(&LISTATTRIBUTESINPUT_MEMBER_CLUSTER, val)?;
-138
+        }
         if let Some(ref val) = self.target_type {
             ser.write_string(&LISTATTRIBUTESINPUT_MEMBER_TARGET_TYPE, val.as_str())?;
-141
+        }
         if let Some(ref val) = self.attribute_name {
             ser.write_string(&LISTATTRIBUTESINPUT_MEMBER_ATTRIBUTE_NAME, val)?;
-144
+        }
         if let Some(ref val) = self.attribute_value {
             ser.write_string(&LISTATTRIBUTESINPUT_MEMBER_ATTRIBUTE_VALUE, val)?;
-147
+        }
         if let Some(ref val) = self.next_token {
             ser.write_string(&LISTATTRIBUTESINPUT_MEMBER_NEXT_TOKEN, val)?;
-150
+        }
         if let Some(ref val) = self.max_results {
             ser.write_integer(&LISTATTRIBUTESINPUT_MEMBER_MAX_RESULTS, *val)?;
-153
+        }
         Ok(())
-155
+    }
-156
+}
 impl ListAttributesInput {
     /// 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(&LISTATTRIBUTESINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTATTRIBUTESINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cluster = Some(deser.read_string(member)?);
-175
+                }
                 Some(1) => {
                     builder.target_type = Some(crate::types::TargetType::from(deser.read_string(member)?.as_str()));
-178
+                }
                 Some(2) => {
                     builder.attribute_name = Some(deser.read_string(member)?);
-181
+                }
                 Some(3) => {
                     builder.attribute_value = Some(deser.read_string(member)?);
-184
+                }
                 Some(4) => {
                     builder.next_token = Some(deser.read_string(member)?);
-187
+                }
                 Some(5) => {
                     builder.max_results = Some(deser.read_integer(member)?);
-190
+                }
                 _ => {}
-192
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-198
+    }
-199
+}
 impl ListAttributesInput {
     /// 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 ListAttributesInput {
     /// Creates a new builder-style object to manufacture [`ListAttributesInput`](crate::operation::list_attributes::ListAttributesInput).
     pub fn builder() -> crate::operation::list_attributes::builders::ListAttributesInputBuilder {
         crate::operation::list_attributes::builders::ListAttributesInputBuilder::default()
-215
+    }
-216
+}
-217
 /// A builder for [`ListAttributesInput`](crate::operation::list_attributes::ListAttributesInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ListAttributesInputBuilder {
     pub(crate) cluster: ::std::option::Option<::std::string::String>,
     pub(crate) target_type: ::std::option::Option<crate::types::TargetType>,
     pub(crate) attribute_name: ::std::option::Option<::std::string::String>,
     pub(crate) attribute_value: ::std::option::Option<::std::string::String>,
     pub(crate) next_token: ::std::option::Option<::std::string::String>,
     pub(crate) max_results: ::std::option::Option<i32>,
-228
+}
 impl ListAttributesInputBuilder {
     /// <p>The short name or full Amazon Resource Name (ARN) of the cluster to list attributes. If you do not specify a cluster, the default cluster is assumed.</p>
     pub fn cluster(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.cluster = ::std::option::Option::Some(input.into());
         self
-234
+    }
     /// <p>The short name or full Amazon Resource Name (ARN) of the cluster to list attributes. If you do not specify a cluster, the default cluster is assumed.</p>
     pub fn set_cluster(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.cluster = input;
         self
-239
+    }
     /// <p>The short name or full Amazon Resource Name (ARN) of the cluster to list attributes. If you do not specify a cluster, the default cluster is assumed.</p>

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/list_attributes/_list_attributes_output.rs

@@ -16,16 +137,192 @@

↥ Expand context

     pub fn attributes(&self) -> &[crate::types::Attribute] {
         self.attributes.as_deref().unwrap_or_default()
-18
+    }
     /// <p>The <code>nextToken</code> value to include in a future <code>ListAttributes</code> request. When the results of a <code>ListAttributes</code> request exceed <code>maxResults</code>, this value can be used to retrieve the next page of results. This value is <code>null</code> when there are no more results to return.</p>
     pub fn next_token(&self) -> ::std::option::Option<&str> {
         self.next_token.as_deref()
-22
+    }
-23
+}
 static LISTATTRIBUTESOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs.synthetic#ListAttributesOutput",
     "com.amazonaws.ecs.synthetic",
     "ListAttributesOutput",
 );
 static LISTATTRIBUTESOUTPUT_MEMBER_ATTRIBUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAttributesOutput$attributes",
         "com.amazonaws.ecs.synthetic",
         "ListAttributesOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,

     "attributes",
 ,
 );
 static LISTATTRIBUTESOUTPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#ListAttributesOutput$nextToken",
         "com.amazonaws.ecs.synthetic",
         "ListAttributesOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_token",
     "nextToken",
 ,
 );
 static LISTATTRIBUTESOUTPUT_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 LISTATTRIBUTESOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTATTRIBUTESOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&LISTATTRIBUTESOUTPUT_MEMBER_ATTRIBUTES, &LISTATTRIBUTESOUTPUT_MEMBER_NEXT_TOKEN],
     &[
         &LISTATTRIBUTESOUTPUT_MEMBER_ATTRIBUTES,
         &LISTATTRIBUTESOUTPUT_MEMBER_NEXT_TOKEN,
         &LISTATTRIBUTESOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ListAttributesOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTATTRIBUTESOUTPUT_SCHEMA;
-68
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListAttributesOutput {
     #[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.attributes {
             ser.write_list(
                 &LISTATTRIBUTESOUTPUT_MEMBER_ATTRIBUTES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Attribute::SCHEMA, item)?;
-81
+                    }
                     Ok(())
                 },
             )?;
-85
+        }
         if let Some(ref val) = self.next_token {
             ser.write_string(&LISTATTRIBUTESOUTPUT_MEMBER_NEXT_TOKEN, val)?;
-88
+        }
         Ok(())
-90
+    }
-91
+}
 impl ListAttributesOutput {
     /// 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(&LISTATTRIBUTESOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTATTRIBUTESOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.attributes = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Attribute::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 ListAttributesOutput {
     /// 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(&LISTATTRIBUTESOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.attributes = 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::Attribute::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Attribute::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 ListAttributesOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-178
+    }
-179
+}
 impl ListAttributesOutput {
     /// Creates a new builder-style object to manufacture [`ListAttributesOutput`](crate::operation::list_attributes::ListAttributesOutput).
     pub fn builder() -> crate::operation::list_attributes::builders::ListAttributesOutputBuilder {
         crate::operation::list_attributes::builders::ListAttributesOutputBuilder::default()
-184
+    }
-185
+}
-186
 /// A builder for [`ListAttributesOutput`](crate::operation::list_attributes::ListAttributesOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListAttributesOutputBuilder {
     pub(crate) attributes: ::std::option::Option<::std::vec::Vec<crate::types::Attribute>>,
     pub(crate) next_token: ::std::option::Option<::std::string::String>,

AWS SDK

Files changed: