AWS SDK

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

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

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

@@ -118,122 +247,384 @@

↥ 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("UpdateCapacityProvider")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UpdateCapacityProviderEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::update_capacity_provider::UpdateCapacityProviderError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::update_capacity_provider::UpdateCapacityProviderError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::update_capacity_provider::UpdateCapacityProviderError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct UpdateCapacityProviderResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UpdateCapacityProviderResponseDeserializer {
     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_update_capacity_provider::de_update_capacity_provider_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::update_capacity_provider::UpdateCapacityProviderError::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::update_capacity_provider::UpdateCapacityProviderError::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::update_capacity_provider::UpdateCapacityProviderError::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::update_capacity_provider::UpdateCapacityProviderError::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::update_capacity_provider::UpdateCapacityProviderError::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::update_capacity_provider::UpdateCapacityProviderError::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::update_capacity_provider::UpdateCapacityProviderError::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_update_capacity_provider::de_update_capacity_provider_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, UpdateCapacityProvider::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::update_capacity_provider::UpdateCapacityProviderOutput::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))
-+
+        }
-333
+    }
-334
+}
 #[derive(Debug)]
 struct UpdateCapacityProviderRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateCapacityProviderRequestSerializer {
     #[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::update_capacity_provider::UpdateCapacityProviderInput>()
             .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::update_capacity_provider::UpdateCapacityProviderInput,
                 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::update_capacity_provider::UpdateCapacityProviderInput,
                 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.UpdateCapacityProvider",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_update_capacity_provider::ser_update_capacity_provider_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, UpdateCapacityProvider::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-355
+    }
-356
+}
 #[derive(Debug)]
 struct UpdateCapacityProviderEndpointParamsInterceptor;
-359
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateCapacityProviderEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateCapacityProviderEndpointParamsInterceptor"
-363
+    }
-364

↧ 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::<UpdateCapacityProviderInput>()
             .ok_or("failed to downcast to UpdateCapacityProviderInput")?;
-379
         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/update_capacity_provider/_update_capacity_provider_input.rs

@@ -35,35 +179,191 @@

↥ Expand context

     "com.amazonaws.ecs.synthetic",
     "UpdateCapacityProviderInput",
 );
 static UPDATECAPACITYPROVIDERINPUT_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#UpdateCapacityProviderInput$name",
         "com.amazonaws.ecs.synthetic",
         "UpdateCapacityProviderInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "name",
 ,
 );
 static UPDATECAPACITYPROVIDERINPUT_MEMBER_CLUSTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#UpdateCapacityProviderInput$cluster",
         "com.amazonaws.ecs.synthetic",
         "UpdateCapacityProviderInput",
     ),
     ::aws_smithy_schema::ShapeType::String,

     "cluster",
 ,
 );
 static UPDATECAPACITYPROVIDERINPUT_MEMBER_AUTO_SCALING_GROUP_PROVIDER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#UpdateCapacityProviderInput$autoScalingGroupProvider",
         "com.amazonaws.ecs.synthetic",
         "UpdateCapacityProviderInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "auto_scaling_group_provider",
     "autoScalingGroupProvider",
 ,
 );
 static UPDATECAPACITYPROVIDERINPUT_MEMBER_MANAGED_INSTANCES_PROVIDER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#UpdateCapacityProviderInput$managedInstancesProvider",
         "com.amazonaws.ecs.synthetic",
         "UpdateCapacityProviderInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "managed_instances_provider",
     "managedInstancesProvider",
 ,
 );
 static UPDATECAPACITYPROVIDERINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATECAPACITYPROVIDERINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UPDATECAPACITYPROVIDERINPUT_MEMBER_NAME,
         &UPDATECAPACITYPROVIDERINPUT_MEMBER_CLUSTER,
         &UPDATECAPACITYPROVIDERINPUT_MEMBER_AUTO_SCALING_GROUP_PROVIDER,
         &UPDATECAPACITYPROVIDERINPUT_MEMBER_MANAGED_INSTANCES_PROVIDER,
     ],
 );
 impl UpdateCapacityProviderInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATECAPACITYPROVIDERINPUT_SCHEMA;
-91
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateCapacityProviderInput {
     #[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(&UPDATECAPACITYPROVIDERINPUT_MEMBER_NAME, val)?;
-100
+        }
         if let Some(ref val) = self.cluster {
             ser.write_string(&UPDATECAPACITYPROVIDERINPUT_MEMBER_CLUSTER, val)?;
-103
+        }
         if let Some(ref val) = self.auto_scaling_group_provider {
             ser.write_struct(&UPDATECAPACITYPROVIDERINPUT_MEMBER_AUTO_SCALING_GROUP_PROVIDER, val)?;
-106
+        }
         if let Some(ref val) = self.managed_instances_provider {
             ser.write_struct(&UPDATECAPACITYPROVIDERINPUT_MEMBER_MANAGED_INSTANCES_PROVIDER, val)?;
-109
+        }
         Ok(())
-111
+    }
-112
+}
 impl UpdateCapacityProviderInput {
     /// 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(&UPDATECAPACITYPROVIDERINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATECAPACITYPROVIDERINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.name = Some(deser.read_string(member)?);
-131
+                }
                 Some(1) => {
                     builder.cluster = Some(deser.read_string(member)?);
-134
+                }
                 Some(2) => {
                     builder.auto_scaling_group_provider = Some(crate::types::AutoScalingGroupProviderUpdate::deserialize(deser)?);
-137
+                }
                 Some(3) => {
                     builder.managed_instances_provider = Some(crate::types::UpdateManagedInstancesProviderConfiguration::deserialize(deser)?);
-140
+                }
                 _ => {}
-142
+            }
             Ok(())
         })?;
         builder.name = builder.name.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-149
+    }
-150
+}
 impl UpdateCapacityProviderInput {
     /// 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 UpdateCapacityProviderInput {
     /// Creates a new builder-style object to manufacture [`UpdateCapacityProviderInput`](crate::operation::update_capacity_provider::UpdateCapacityProviderInput).
     pub fn builder() -> crate::operation::update_capacity_provider::builders::UpdateCapacityProviderInputBuilder {
         crate::operation::update_capacity_provider::builders::UpdateCapacityProviderInputBuilder::default()
-166
+    }
-167
+}
-168
 /// A builder for [`UpdateCapacityProviderInput`](crate::operation::update_capacity_provider::UpdateCapacityProviderInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct UpdateCapacityProviderInputBuilder {
     pub(crate) name: ::std::option::Option<::std::string::String>,
     pub(crate) cluster: ::std::option::Option<::std::string::String>,
     pub(crate) auto_scaling_group_provider: ::std::option::Option<crate::types::AutoScalingGroupProviderUpdate>,
     pub(crate) managed_instances_provider: ::std::option::Option<crate::types::UpdateManagedInstancesProviderConfiguration>,
-177
+}
 impl UpdateCapacityProviderInputBuilder {
     /// <p>The name of the capacity provider to update.</p>
     /// This field is required.
     pub fn name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.name = ::std::option::Option::Some(input.into());
         self
-184
+    }
     /// <p>The name of the capacity provider to update.</p>
     pub fn set_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.name = input;
         self
-189
+    }
     /// <p>The name of the capacity provider to update.</p>
     pub fn get_name(&self) -> &::std::option::Option<::std::string::String> {

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

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct UpdateCapacityProviderOutput {
     /// <p>Details about the capacity provider.</p>
     pub capacity_provider: ::std::option::Option<crate::types::CapacityProvider>,
     _request_id: Option<String>,
-9
+}
 impl UpdateCapacityProviderOutput {
     /// <p>Details about the capacity provider.</p>
     pub fn capacity_provider(&self) -> ::std::option::Option<&crate::types::CapacityProvider> {
         self.capacity_provider.as_ref()
-14
+    }
-15
+}
 static UPDATECAPACITYPROVIDEROUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs.synthetic#UpdateCapacityProviderOutput",

     "com.amazonaws.ecs.synthetic",
     "UpdateCapacityProviderOutput",
 );
 static UPDATECAPACITYPROVIDEROUTPUT_MEMBER_CAPACITY_PROVIDER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#UpdateCapacityProviderOutput$capacityProvider",
         "com.amazonaws.ecs.synthetic",
         "UpdateCapacityProviderOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "capacity_provider",
     "capacityProvider",
 ,
 );
 static UPDATECAPACITYPROVIDEROUTPUT_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 UPDATECAPACITYPROVIDEROUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATECAPACITYPROVIDEROUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&UPDATECAPACITYPROVIDEROUTPUT_MEMBER_CAPACITY_PROVIDER],
     &[
         &UPDATECAPACITYPROVIDEROUTPUT_MEMBER_CAPACITY_PROVIDER,
         &UPDATECAPACITYPROVIDEROUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl UpdateCapacityProviderOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATECAPACITYPROVIDEROUTPUT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateCapacityProviderOutput {
     #[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.capacity_provider {
             ser.write_struct(&UPDATECAPACITYPROVIDEROUTPUT_MEMBER_CAPACITY_PROVIDER, val)?;
-58
+        }
         Ok(())
-60
+    }
-61
+}
 impl UpdateCapacityProviderOutput {
     /// 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(&UPDATECAPACITYPROVIDEROUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATECAPACITYPROVIDEROUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.capacity_provider = Some(crate::types::CapacityProvider::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl UpdateCapacityProviderOutput {
     /// 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(&UPDATECAPACITYPROVIDEROUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.capacity_provider = Some(crate::types::CapacityProvider::deserialize(deser)?);
-117
+                }
                 _ => {}
-119
+            }
             Ok(())
         })?;
         Ok(builder.build())
-123
+    }

↧ Expand context

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

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

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

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

@@ -115,119 +242,375 @@

↥ 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("UpdateCluster")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UpdateClusterEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::update_cluster::UpdateClusterError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::update_cluster::UpdateClusterError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::update_cluster::UpdateClusterError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct UpdateClusterResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UpdateClusterResponseDeserializer {
     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_update_cluster::de_update_cluster_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::update_cluster::UpdateClusterError::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::update_cluster::UpdateClusterError::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::update_cluster::UpdateClusterError::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::update_cluster::UpdateClusterError::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
                 }),
                 "NamespaceNotFoundException" => crate::operation::update_cluster::UpdateClusterError::NamespaceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::NamespaceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::NamespaceNotFoundException::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::update_cluster::UpdateClusterError::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::update_cluster::UpdateClusterError::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_update_cluster::de_update_cluster_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, UpdateCluster::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::update_cluster::UpdateClusterOutput::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))
-+
+        }
-324
+    }
-325
+}
 #[derive(Debug)]
 struct UpdateClusterRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateClusterRequestSerializer {
     #[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::update_cluster::UpdateClusterInput>()
             .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::update_cluster::UpdateClusterInput,
                 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::update_cluster::UpdateClusterInput,
                 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.UpdateCluster",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_cluster::ser_update_cluster_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, UpdateCluster::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-346
+    }
-347
+}
 #[derive(Debug)]
 struct UpdateClusterEndpointParamsInterceptor;
-350
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateClusterEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateClusterEndpointParamsInterceptor"
-354
+    }
-355

↧ 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::<UpdateClusterInput>()
             .ok_or("failed to downcast to UpdateClusterInput")?;
-370
         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/update_cluster/_update_cluster_input.rs

@@ -49,49 +201,210 @@

↥ Expand context

     "cluster",
 ,
 );
 static UPDATECLUSTERINPUT_MEMBER_SETTINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#UpdateClusterInput$settings",
         "com.amazonaws.ecs.synthetic",
         "UpdateClusterInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "settings",
 ,
 );
 static UPDATECLUSTERINPUT_MEMBER_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#UpdateClusterInput$configuration",
         "com.amazonaws.ecs.synthetic",
         "UpdateClusterInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,

     "configuration",
 ,
 );
 static UPDATECLUSTERINPUT_MEMBER_SERVICE_CONNECT_DEFAULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#UpdateClusterInput$serviceConnectDefaults",
         "com.amazonaws.ecs.synthetic",
         "UpdateClusterInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "service_connect_defaults",
     "serviceConnectDefaults",
 ,
 );
 static UPDATECLUSTERINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATECLUSTERINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UPDATECLUSTERINPUT_MEMBER_CLUSTER,
         &UPDATECLUSTERINPUT_MEMBER_SETTINGS,
         &UPDATECLUSTERINPUT_MEMBER_CONFIGURATION,
         &UPDATECLUSTERINPUT_MEMBER_SERVICE_CONNECT_DEFAULTS,
     ],
 );
 impl UpdateClusterInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATECLUSTERINPUT_SCHEMA;
-95
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateClusterInput {
     #[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(&UPDATECLUSTERINPUT_MEMBER_CLUSTER, val)?;
-104
+        }
         if let Some(ref val) = self.settings {
             ser.write_list(
                 &UPDATECLUSTERINPUT_MEMBER_SETTINGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::ClusterSetting::SCHEMA, item)?;
-111
+                    }
                     Ok(())
                 },
             )?;
-115
+        }
         if let Some(ref val) = self.configuration {
             ser.write_struct(&UPDATECLUSTERINPUT_MEMBER_CONFIGURATION, val)?;
-118
+        }
         if let Some(ref val) = self.service_connect_defaults {
             ser.write_struct(&UPDATECLUSTERINPUT_MEMBER_SERVICE_CONNECT_DEFAULTS, val)?;
-121
+        }
         Ok(())
-123
+    }
-124
+}
 impl UpdateClusterInput {
     /// 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(&UPDATECLUSTERINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATECLUSTERINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cluster = Some(deser.read_string(member)?);
-143
+                }
                 Some(1) => {
                     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::ClusterSetting::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ClusterSetting::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-153
+                }
                 Some(2) => {
                     builder.configuration = Some(crate::types::ClusterConfiguration::deserialize(deser)?);
-156
+                }
                 Some(3) => {
                     builder.service_connect_defaults = Some(crate::types::ClusterServiceConnectDefaultsRequest::deserialize(deser)?);
-159
+                }
                 _ => {}
-161
+            }
             Ok(())
         })?;
         builder.cluster = builder.cluster.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-168
+    }
-169
+}
 impl UpdateClusterInput {
     /// 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 UpdateClusterInput {
     /// Creates a new builder-style object to manufacture [`UpdateClusterInput`](crate::operation::update_cluster::UpdateClusterInput).
     pub fn builder() -> crate::operation::update_cluster::builders::UpdateClusterInputBuilder {
         crate::operation::update_cluster::builders::UpdateClusterInputBuilder::default()
-185
+    }
-186
+}
-187
 /// A builder for [`UpdateClusterInput`](crate::operation::update_cluster::UpdateClusterInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct UpdateClusterInputBuilder {
     pub(crate) cluster: ::std::option::Option<::std::string::String>,
     pub(crate) settings: ::std::option::Option<::std::vec::Vec<crate::types::ClusterSetting>>,
     pub(crate) configuration: ::std::option::Option<crate::types::ClusterConfiguration>,
     pub(crate) service_connect_defaults: ::std::option::Option<crate::types::ClusterServiceConnectDefaultsRequest>,
-196
+}
 impl UpdateClusterInputBuilder {
     /// <p>The name of the cluster to modify the settings for.</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
-203
+    }
     /// <p>The name of the cluster to modify the settings for.</p>
     pub fn set_cluster(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.cluster = input;
         self
-208
+    }
     /// <p>The name of the cluster to modify the settings for.</p>
     pub fn get_cluster(&self) -> &::std::option::Option<::std::string::String> {

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

@@ -1,1 +96,140 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct UpdateClusterOutput {
     /// <p>Details about the cluster.</p>
     pub cluster: ::std::option::Option<crate::types::Cluster>,
     _request_id: Option<String>,
-9
+}
 impl UpdateClusterOutput {
     /// <p>Details about the cluster.</p>
     pub fn cluster(&self) -> ::std::option::Option<&crate::types::Cluster> {
         self.cluster.as_ref()
-14
+    }
-15
+}
 static UPDATECLUSTEROUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs.synthetic#UpdateClusterOutput",
     "com.amazonaws.ecs.synthetic",
     "UpdateClusterOutput",
 );

 static UPDATECLUSTEROUTPUT_MEMBER_CLUSTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#UpdateClusterOutput$cluster",
         "com.amazonaws.ecs.synthetic",
         "UpdateClusterOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "cluster",
 ,
 );
 static UPDATECLUSTEROUTPUT_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 UPDATECLUSTEROUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATECLUSTEROUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&UPDATECLUSTEROUTPUT_MEMBER_CLUSTER],
     &[&UPDATECLUSTEROUTPUT_MEMBER_CLUSTER, &UPDATECLUSTEROUTPUT_MEMBER__REQUEST_ID],
 );
 impl UpdateClusterOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATECLUSTEROUTPUT_SCHEMA;
-46
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateClusterOutput {
     #[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_struct(&UPDATECLUSTEROUTPUT_MEMBER_CLUSTER, val)?;
-55
+        }
         Ok(())
-57
+    }
-58
+}
 impl UpdateClusterOutput {
     /// 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(&UPDATECLUSTEROUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATECLUSTEROUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cluster = Some(crate::types::Cluster::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl UpdateClusterOutput {
     /// 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(&UPDATECLUSTEROUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cluster = Some(crate::types::Cluster::deserialize(deser)?);
-114
+                }
                 _ => {}
-116
+            }
             Ok(())
         })?;
         Ok(builder.build())
-120
+    }

↧ Expand context

-121
+}
 impl ::aws_types::request_id::RequestId for UpdateClusterOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-125
+    }
-126
+}
 impl UpdateClusterOutput {
     /// Creates a new builder-style object to manufacture [`UpdateClusterOutput`](crate::operation::update_cluster::UpdateClusterOutput).
     pub fn builder() -> crate::operation::update_cluster::builders::UpdateClusterOutputBuilder {
         crate::operation::update_cluster::builders::UpdateClusterOutputBuilder::default()
-131
+    }
-132
+}
-133
 /// A builder for [`UpdateClusterOutput`](crate::operation::update_cluster::UpdateClusterOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UpdateClusterOutputBuilder {
     pub(crate) cluster: ::std::option::Option<crate::types::Cluster>,
     _request_id: Option<String>,
-140
+}

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/update_cluster_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 `UpdateClusterSettings`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UpdateClusterSettings;
 impl UpdateClusterSettings {
     /// Creates a new `UpdateClusterSettings`
     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::update_cluster_settings::UpdateClusterSettingsInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::update_cluster_settings::UpdateClusterSettingsOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::update_cluster_settings::UpdateClusterSettingsInput,
     ) -> ::std::result::Result<
         crate::operation::update_cluster_settings::UpdateClusterSettingsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::update_cluster_settings::UpdateClusterSettingsError,
             ::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::update_cluster_settings::UpdateClusterSettingsError>()
                     .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::update_cluster_settings::UpdateClusterSettingsOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -118,122 +247,358 @@

↥ 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("UpdateClusterSettings")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UpdateClusterSettingsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::update_cluster_settings::UpdateClusterSettingsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::update_cluster_settings::UpdateClusterSettingsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::update_cluster_settings::UpdateClusterSettingsError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct UpdateClusterSettingsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UpdateClusterSettingsResponseDeserializer {
     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_update_cluster_settings::de_update_cluster_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::update_cluster_settings::UpdateClusterSettingsError::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::update_cluster_settings::UpdateClusterSettingsError::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::update_cluster_settings::UpdateClusterSettingsError::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::update_cluster_settings::UpdateClusterSettingsError::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::update_cluster_settings::UpdateClusterSettingsError::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::update_cluster_settings::UpdateClusterSettingsError::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_update_cluster_settings::de_update_cluster_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, UpdateClusterSettings::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::update_cluster_settings::UpdateClusterSettingsOutput::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))
-+
+        }
-307
+    }
-308
+}
 #[derive(Debug)]
 struct UpdateClusterSettingsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateClusterSettingsRequestSerializer {
     #[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::update_cluster_settings::UpdateClusterSettingsInput>()
             .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::update_cluster_settings::UpdateClusterSettingsInput,
                 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::update_cluster_settings::UpdateClusterSettingsInput,
                 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.UpdateClusterSettings",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_cluster_settings::ser_update_cluster_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, UpdateClusterSettings::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-329
+    }
-330
+}
 #[derive(Debug)]
 struct UpdateClusterSettingsEndpointParamsInterceptor;
-333
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateClusterSettingsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateClusterSettingsEndpointParamsInterceptor"
-337
+    }
-338

↧ 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::<UpdateClusterSettingsInput>()
             .ok_or("failed to downcast to UpdateClusterSettingsInput")?;
-353
         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/update_cluster_settings/_update_cluster_settings_input.rs

@@ -56,56 +154,164 @@

↥ Expand context

 );
 impl UpdateClusterSettingsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATECLUSTERSETTINGSINPUT_SCHEMA;
-60
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateClusterSettingsInput {
     #[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(&UPDATECLUSTERSETTINGSINPUT_MEMBER_CLUSTER, val)?;
-69
+        }
         if let Some(ref val) = self.settings {
             ser.write_list(
                 &UPDATECLUSTERSETTINGSINPUT_MEMBER_SETTINGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::ClusterSetting::SCHEMA, item)?;

-76
+                    }
                     Ok(())
                 },
             )?;
-80
+        }
         Ok(())
-82
+    }
-83
+}
 impl UpdateClusterSettingsInput {
     /// 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(&UPDATECLUSTERSETTINGSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATECLUSTERSETTINGSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cluster = Some(deser.read_string(member)?);
-102
+                }
                 Some(1) => {
                     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::ClusterSetting::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ClusterSetting::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-112
+                }
                 _ => {}
-114
+            }
             Ok(())
         })?;
         builder.cluster = builder.cluster.or(Some(String::new()));
         builder.settings = builder.settings.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-122
+    }
-123
+}
 impl UpdateClusterSettingsInput {
     /// 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 UpdateClusterSettingsInput {
     /// Creates a new builder-style object to manufacture [`UpdateClusterSettingsInput`](crate::operation::update_cluster_settings::UpdateClusterSettingsInput).
     pub fn builder() -> crate::operation::update_cluster_settings::builders::UpdateClusterSettingsInputBuilder {
         crate::operation::update_cluster_settings::builders::UpdateClusterSettingsInputBuilder::default()
-139
+    }
-140
+}
-141
 /// A builder for [`UpdateClusterSettingsInput`](crate::operation::update_cluster_settings::UpdateClusterSettingsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct UpdateClusterSettingsInputBuilder {
     pub(crate) cluster: ::std::option::Option<::std::string::String>,
     pub(crate) settings: ::std::option::Option<::std::vec::Vec<crate::types::ClusterSetting>>,
-148
+}
 impl UpdateClusterSettingsInputBuilder {
     /// <p>The name of the cluster to modify the settings for.</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
-155
+    }
     /// <p>The name of the cluster to modify the settings for.</p>
     pub fn set_cluster(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.cluster = input;
         self
-160
+    }
     /// <p>The name of the cluster to modify the settings for.</p>
     pub fn get_cluster(&self) -> &::std::option::Option<::std::string::String> {
         &self.cluster
-164
+    }

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

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct UpdateClusterSettingsOutput {
     /// <p>Details about the cluster</p>
     pub cluster: ::std::option::Option<crate::types::Cluster>,
     _request_id: Option<String>,
-9
+}
 impl UpdateClusterSettingsOutput {
     /// <p>Details about the cluster</p>
     pub fn cluster(&self) -> ::std::option::Option<&crate::types::Cluster> {
         self.cluster.as_ref()
-14
+    }
-15
+}
 static UPDATECLUSTERSETTINGSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs.synthetic#UpdateClusterSettingsOutput",
     "com.amazonaws.ecs.synthetic",
     "UpdateClusterSettingsOutput",
 );

 static UPDATECLUSTERSETTINGSOUTPUT_MEMBER_CLUSTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs.synthetic#UpdateClusterSettingsOutput$cluster",
         "com.amazonaws.ecs.synthetic",
         "UpdateClusterSettingsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "cluster",
 ,
 );
 static UPDATECLUSTERSETTINGSOUTPUT_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 UPDATECLUSTERSETTINGSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATECLUSTERSETTINGSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&UPDATECLUSTERSETTINGSOUTPUT_MEMBER_CLUSTER],
     &[
         &UPDATECLUSTERSETTINGSOUTPUT_MEMBER_CLUSTER,
         &UPDATECLUSTERSETTINGSOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl UpdateClusterSettingsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATECLUSTERSETTINGSOUTPUT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateClusterSettingsOutput {
     #[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_struct(&UPDATECLUSTERSETTINGSOUTPUT_MEMBER_CLUSTER, val)?;
-58
+        }
         Ok(())
-60
+    }
-61
+}
 impl UpdateClusterSettingsOutput {
     /// 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(&UPDATECLUSTERSETTINGSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATECLUSTERSETTINGSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cluster = Some(crate::types::Cluster::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl UpdateClusterSettingsOutput {
     /// 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(&UPDATECLUSTERSETTINGSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cluster = Some(crate::types::Cluster::deserialize(deser)?);
-117
+                }
                 _ => {}
-119
+            }
             Ok(())
         })?;
         Ok(builder.build())
-123
+    }

↧ Expand context

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

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

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

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

@@ -118,122 +247,430 @@

↥ 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("UpdateContainerAgent")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UpdateContainerAgentEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::update_container_agent::UpdateContainerAgentError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::update_container_agent::UpdateContainerAgentError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::update_container_agent::UpdateContainerAgentError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct UpdateContainerAgentResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UpdateContainerAgentResponseDeserializer {
     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_update_container_agent::de_update_container_agent_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::update_container_agent::UpdateContainerAgentError::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::update_container_agent::UpdateContainerAgentError::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::update_container_agent::UpdateContainerAgentError::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::update_container_agent::UpdateContainerAgentError::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
                 }),
                 "MissingVersionException" => crate::operation::update_container_agent::UpdateContainerAgentError::MissingVersionException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::MissingVersionException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::MissingVersionException::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
                 }),
                 "NoUpdateAvailableException" => crate::operation::update_container_agent::UpdateContainerAgentError::NoUpdateAvailableException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::NoUpdateAvailableException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::NoUpdateAvailableException::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::update_container_agent::UpdateContainerAgentError::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
                 }),
                 "UpdateInProgressException" => crate::operation::update_container_agent::UpdateContainerAgentError::UpdateInProgressException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::UpdateInProgressException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::UpdateInProgressException::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::update_container_agent::UpdateContainerAgentError::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_update_container_agent::de_update_container_agent_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, UpdateContainerAgent::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::update_container_agent::UpdateContainerAgentOutput::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))
-+
+        }
-379
+    }
-380
+}
 #[derive(Debug)]
 struct UpdateContainerAgentRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateContainerAgentRequestSerializer {
     #[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::update_container_agent::UpdateContainerAgentInput>()
             .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::update_container_agent::UpdateContainerAgentInput,
                 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::update_container_agent::UpdateContainerAgentInput,
                 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.UpdateContainerAgent",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_container_agent::ser_update_container_agent_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, UpdateContainerAgent::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-401
+    }
-402
+}
 #[derive(Debug)]
 struct UpdateContainerAgentEndpointParamsInterceptor;
-405
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateContainerAgentEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateContainerAgentEndpointParamsInterceptor"
-409
+    }
-410

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

AWS SDK

Files changed: