AWS SDK

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_deployment_circuit_breaker.rs

@@ -49,49 +135,146 @@

 ,
 );
 static DEPLOYMENTCIRCUITBREAKER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DEPLOYMENTCIRCUITBREAKER_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DEPLOYMENTCIRCUITBREAKER_MEMBER_ENABLE, &DEPLOYMENTCIRCUITBREAKER_MEMBER_ROLLBACK],
 );
 impl DeploymentCircuitBreaker {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEPLOYMENTCIRCUITBREAKER_SCHEMA;
-59
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeploymentCircuitBreaker {
     #[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> {
-66
+        {
             let val = &self.enable;
             ser.write_boolean(&DEPLOYMENTCIRCUITBREAKER_MEMBER_ENABLE, *val)?;

-69
+        }
-70
+        {
             let val = &self.rollback;
             ser.write_boolean(&DEPLOYMENTCIRCUITBREAKER_MEMBER_ROLLBACK, *val)?;
-73
+        }
         Ok(())
-75
+    }
-76
+}
 impl DeploymentCircuitBreaker {
     /// 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(&DEPLOYMENTCIRCUITBREAKER_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DEPLOYMENTCIRCUITBREAKER_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.enable = Some(deser.read_boolean(member)?);
-95
+                }
                 Some(1) => {
                     builder.rollback = Some(deser.read_boolean(member)?);
-98
+                }
                 _ => {}
-100
+            }
             Ok(())
         })?;
         Ok(builder.build())
-104
+    }
-105
+}
 impl DeploymentCircuitBreaker {
     /// 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 DeploymentCircuitBreaker {
     /// Creates a new builder-style object to manufacture [`DeploymentCircuitBreaker`](crate::types::DeploymentCircuitBreaker).
     pub fn builder() -> crate::types::builders::DeploymentCircuitBreakerBuilder {
         crate::types::builders::DeploymentCircuitBreakerBuilder::default()
-121
+    }
-122
+}
-123
 /// A builder for [`DeploymentCircuitBreaker`](crate::types::DeploymentCircuitBreaker).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DeploymentCircuitBreakerBuilder {
     pub(crate) enable: ::std::option::Option<bool>,
     pub(crate) rollback: ::std::option::Option<bool>,
-130
+}
 impl DeploymentCircuitBreakerBuilder {
     /// <p>Determines whether to use the deployment circuit breaker logic for the service.</p>
     /// This field is required.
     pub fn enable(mut self, input: bool) -> Self {
         self.enable = ::std::option::Option::Some(input);
         self
-137
+    }
     /// <p>Determines whether to use the deployment circuit breaker logic for the service.</p>
     pub fn set_enable(mut self, input: ::std::option::Option<bool>) -> Self {
         self.enable = input;
         self
-142
+    }
     /// <p>Determines whether to use the deployment circuit breaker logic for the service.</p>
     pub fn get_enable(&self) -> &::std::option::Option<bool> {
         &self.enable
-146
+    }

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_deployment_configuration.rs

@@ -112,112 +343,351 @@

↥ Expand context

     /// <li>
     /// <p><code>BLUE_GREEN</code> - A blue/green deployment strategy (<code>BLUE_GREEN</code>) is a release methodology that reduces downtime and risk by running two identical production environments called blue and green. With Amazon ECS blue/green deployments, you can validate new service revisions before directing production traffic to them. This approach provides a safer way to deploy changes with the ability to quickly roll back if needed.</p></li>
     /// </ul>
     pub fn strategy(&self) -> ::std::option::Option<&crate::types::DeploymentStrategy> {
         self.strategy.as_ref()
-117
+    }
     /// <p>The time period when both blue and green service revisions are running simultaneously after the production traffic has shifted.</p>
     /// <p>You must provide this parameter when you use the <code>BLUE_GREEN</code> deployment strategy.</p>
     pub fn bake_time_in_minutes(&self) -> ::std::option::Option<i32> {
         self.bake_time_in_minutes
-122
+    }
     /// <p>An array of deployment lifecycle hook objects to run custom logic at specific stages of the deployment lifecycle.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.lifecycle_hooks.is_none()`.
     pub fn lifecycle_hooks(&self) -> &[crate::types::DeploymentLifecycleHook] {
         self.lifecycle_hooks.as_deref().unwrap_or_default()
-128
+    }
-129
+}
 static DEPLOYMENTCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs#DeploymentConfiguration",

     "com.amazonaws.ecs",
     "DeploymentConfiguration",
 );
 static DEPLOYMENTCONFIGURATION_MEMBER_DEPLOYMENT_CIRCUIT_BREAKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DeploymentConfiguration$deploymentCircuitBreaker",
         "com.amazonaws.ecs",
         "DeploymentConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "deployment_circuit_breaker",
     "deploymentCircuitBreaker",
 ,
 );
 static DEPLOYMENTCONFIGURATION_MEMBER_MAXIMUM_PERCENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DeploymentConfiguration$maximumPercent",
         "com.amazonaws.ecs",
         "DeploymentConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "maximum_percent",
     "maximumPercent",
 ,
 );
 static DEPLOYMENTCONFIGURATION_MEMBER_MINIMUM_HEALTHY_PERCENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DeploymentConfiguration$minimumHealthyPercent",
         "com.amazonaws.ecs",
         "DeploymentConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "minimum_healthy_percent",
     "minimumHealthyPercent",
 ,
 );
 static DEPLOYMENTCONFIGURATION_MEMBER_ALARMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DeploymentConfiguration$alarms",
         "com.amazonaws.ecs",
         "DeploymentConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "alarms",
 ,
 );
 static DEPLOYMENTCONFIGURATION_MEMBER_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DeploymentConfiguration$strategy",
         "com.amazonaws.ecs",
         "DeploymentConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "strategy",
 ,
 );
 static DEPLOYMENTCONFIGURATION_MEMBER_BAKE_TIME_IN_MINUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DeploymentConfiguration$bakeTimeInMinutes",
         "com.amazonaws.ecs",
         "DeploymentConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "bake_time_in_minutes",
     "bakeTimeInMinutes",
 ,
 );
 static DEPLOYMENTCONFIGURATION_MEMBER_LIFECYCLE_HOOKS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DeploymentConfiguration$lifecycleHooks",
         "com.amazonaws.ecs",
         "DeploymentConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "lifecycle_hooks",
     "lifecycleHooks",
 ,
 );
 static DEPLOYMENTCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DEPLOYMENTCONFIGURATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DEPLOYMENTCONFIGURATION_MEMBER_DEPLOYMENT_CIRCUIT_BREAKER,
         &DEPLOYMENTCONFIGURATION_MEMBER_MAXIMUM_PERCENT,
         &DEPLOYMENTCONFIGURATION_MEMBER_MINIMUM_HEALTHY_PERCENT,
         &DEPLOYMENTCONFIGURATION_MEMBER_ALARMS,
         &DEPLOYMENTCONFIGURATION_MEMBER_STRATEGY,
         &DEPLOYMENTCONFIGURATION_MEMBER_BAKE_TIME_IN_MINUTES,
         &DEPLOYMENTCONFIGURATION_MEMBER_LIFECYCLE_HOOKS,
     ],
 );
 impl DeploymentConfiguration {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEPLOYMENTCONFIGURATION_SCHEMA;
-221
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeploymentConfiguration {
     #[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.deployment_circuit_breaker {
             ser.write_struct(&DEPLOYMENTCONFIGURATION_MEMBER_DEPLOYMENT_CIRCUIT_BREAKER, val)?;
-230
+        }
         if let Some(ref val) = self.maximum_percent {
             ser.write_integer(&DEPLOYMENTCONFIGURATION_MEMBER_MAXIMUM_PERCENT, *val)?;
-233
+        }
         if let Some(ref val) = self.minimum_healthy_percent {
             ser.write_integer(&DEPLOYMENTCONFIGURATION_MEMBER_MINIMUM_HEALTHY_PERCENT, *val)?;
-236
+        }
         if let Some(ref val) = self.alarms {
             ser.write_struct(&DEPLOYMENTCONFIGURATION_MEMBER_ALARMS, val)?;
-239
+        }
         if let Some(ref val) = self.strategy {
             ser.write_string(&DEPLOYMENTCONFIGURATION_MEMBER_STRATEGY, val.as_str())?;
-242
+        }
         if let Some(ref val) = self.bake_time_in_minutes {
             ser.write_integer(&DEPLOYMENTCONFIGURATION_MEMBER_BAKE_TIME_IN_MINUTES, *val)?;
-245
+        }
         if let Some(ref val) = self.lifecycle_hooks {
             ser.write_list(
                 &DEPLOYMENTCONFIGURATION_MEMBER_LIFECYCLE_HOOKS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::DeploymentLifecycleHook::SCHEMA, item)?;
-252
+                    }
                     Ok(())
                 },
             )?;
-256
+        }
         Ok(())
-258
+    }
-259
+}
 impl DeploymentConfiguration {
     /// 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(&DEPLOYMENTCONFIGURATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DEPLOYMENTCONFIGURATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.deployment_circuit_breaker = Some(crate::types::DeploymentCircuitBreaker::deserialize(deser)?);
-278
+                }
                 Some(1) => {
                     builder.maximum_percent = Some(deser.read_integer(member)?);
-281
+                }
                 Some(2) => {
                     builder.minimum_healthy_percent = Some(deser.read_integer(member)?);
-284
+                }
                 Some(3) => {
                     builder.alarms = Some(crate::types::DeploymentAlarms::deserialize(deser)?);
-287
+                }
                 Some(4) => {
                     builder.strategy = Some(crate::types::DeploymentStrategy::from(deser.read_string(member)?.as_str()));
-290
+                }
                 Some(5) => {
                     builder.bake_time_in_minutes = Some(deser.read_integer(member)?);
-293
+                }
                 Some(6) => {
                     builder.lifecycle_hooks = 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::DeploymentLifecycleHook::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::DeploymentLifecycleHook::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-303
+                }
                 _ => {}
-305
+            }
             Ok(())
         })?;
         Ok(builder.build())
-309
+    }
-310
+}
 impl DeploymentConfiguration {
     /// 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 DeploymentConfiguration {
     /// Creates a new builder-style object to manufacture [`DeploymentConfiguration`](crate::types::DeploymentConfiguration).
     pub fn builder() -> crate::types::builders::DeploymentConfigurationBuilder {
         crate::types::builders::DeploymentConfigurationBuilder::default()
-326
+    }
-327
+}
-328
 /// A builder for [`DeploymentConfiguration`](crate::types::DeploymentConfiguration).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DeploymentConfigurationBuilder {
     pub(crate) deployment_circuit_breaker: ::std::option::Option<crate::types::DeploymentCircuitBreaker>,
     pub(crate) maximum_percent: ::std::option::Option<i32>,
     pub(crate) minimum_healthy_percent: ::std::option::Option<i32>,
     pub(crate) alarms: ::std::option::Option<crate::types::DeploymentAlarms>,
     pub(crate) strategy: ::std::option::Option<crate::types::DeploymentStrategy>,
     pub(crate) bake_time_in_minutes: ::std::option::Option<i32>,
     pub(crate) lifecycle_hooks: ::std::option::Option<::std::vec::Vec<crate::types::DeploymentLifecycleHook>>,
-340
+}
 impl DeploymentConfigurationBuilder {
     /// <note>
     /// <p>The deployment circuit breaker can only be used for services using the rolling update (<code>ECS</code>) deployment type.</p>
     /// </note>
     /// <p>The <b>deployment circuit breaker</b> determines whether a service deployment will fail if the service can't reach a steady state. If you use the deployment circuit breaker, a service deployment will transition to a failed state and stop launching new tasks. If you use the rollback option, when a service deployment fails, the service is rolled back to the last deployment that completed successfully. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html">Rolling update</a> in the <i>Amazon Elastic Container Service Developer Guide</i></p>
     pub fn deployment_circuit_breaker(mut self, input: crate::types::DeploymentCircuitBreaker) -> Self {
         self.deployment_circuit_breaker = ::std::option::Option::Some(input);
         self
-349
+    }
     /// <note>
     /// <p>The deployment circuit breaker can only be used for services using the rolling update (<code>ECS</code>) deployment type.</p>

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_deployment_controller.rs

@@ -89,89 +201,212 @@

↥ Expand context

     /// <li>
     /// <p><code>BLUE_GREEN</code>: A <i>blue/green</i> deployment strategy (<code>BLUE_GREEN</code>) is a release methodology that reduces downtime and risk by running two identical production environments called blue and green. With Amazon ECS blue/green deployments, you can validate new service revisions before directing production traffic to them. This approach provides a safer way to deploy changes with the ability to quickly roll back if needed.</p>
     /// <p>Amazon ECS blue/green deployments are best suited for the following scenarios:</p>
     /// <ul>
     /// <li>
     /// <p>Service validation: When you need to validate new service revisions before directing production traffic to them</p></li>
     /// <li>
     /// <p>Zero downtime: When your service requires zero-downtime deployments</p></li>
     /// <li>
     /// <p>Instant roll back: When you need the ability to quickly roll back if issues are detected</p></li>
     /// <li>
     /// <p>Load balancer requirement: When your service uses Application Load Balancer, Network Load Balancer, or Service Connect</p></li>
     /// </ul></li>
     /// </ul></li>
     /// <li>
     /// <p>External</p>
     /// <p>Use a third-party deployment controller.</p></li>
     /// <li>
     /// <p>Blue/green deployment (powered by CodeDeploy)</p>
     /// <p>CodeDeploy installs an updated version of the application as a new replacement task set and reroutes production traffic from the original application task set to the replacement task set. The original task set is terminated after a successful deployment. Use this deployment controller to verify a new deployment of a service before sending production traffic to it.</p></li>

     /// </ul>
     pub fn r#type(&self) -> &crate::types::DeploymentControllerType {
         &self.r#type
-112
+    }
-113
+}
 static DEPLOYMENTCONTROLLER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#DeploymentController", "com.amazonaws.ecs", "DeploymentController");
 static DEPLOYMENTCONTROLLER_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#DeploymentController$type", "com.amazonaws.ecs", "DeploymentController"),
     ::aws_smithy_schema::ShapeType::String,
     "r##type",
     "type",
 ,
 );
 static DEPLOYMENTCONTROLLER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DEPLOYMENTCONTROLLER_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DEPLOYMENTCONTROLLER_MEMBER_TYPE],
 );
 impl DeploymentController {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEPLOYMENTCONTROLLER_SCHEMA;
-130
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeploymentController {
     #[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> {
-137
+        {
             let val = &self.r#type;
             ser.write_string(&DEPLOYMENTCONTROLLER_MEMBER_TYPE, val.as_str())?;
-140
+        }
         Ok(())
-142
+    }
-143
+}
 impl DeploymentController {
     /// 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(&DEPLOYMENTCONTROLLER_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DEPLOYMENTCONTROLLER_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.r#type = Some(crate::types::DeploymentControllerType::from(deser.read_string(member)?.as_str()));
-162
+                }
                 _ => {}
-164
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-170
+    }
-171
+}
 impl DeploymentController {
     /// 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 DeploymentController {
     /// Creates a new builder-style object to manufacture [`DeploymentController`](crate::types::DeploymentController).
     pub fn builder() -> crate::types::builders::DeploymentControllerBuilder {
         crate::types::builders::DeploymentControllerBuilder::default()
-187
+    }
-188
+}
-189
 /// A builder for [`DeploymentController`](crate::types::DeploymentController).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DeploymentControllerBuilder {
     pub(crate) r#type: ::std::option::Option<crate::types::DeploymentControllerType>,
-195
+}
 impl DeploymentControllerBuilder {
     /// <p>The deployment controller type to use.</p>
     /// <p>The deployment controller is the mechanism that determines how tasks are deployed for your service. The valid options are:</p>
     /// <ul>
     /// <li>
     /// <p>ECS</p>
     /// <p>When you create a service which uses the <code>ECS</code> deployment controller, you can choose between the following deployment strategies:</p>
     /// <ul>
     /// <li>
     /// <p><code>ROLLING</code>: When you create a service which uses the <i>rolling update</i> (<code>ROLLING</code>) deployment strategy, the Amazon ECS service scheduler replaces the currently running tasks with new tasks. The number of tasks that Amazon ECS adds or removes from the service during a rolling update is controlled by the service deployment configuration.</p>
     /// <p>Rolling update deployments are best suited for the following scenarios:</p>
     /// <ul>
     /// <li>
     /// <p>Gradual service updates: You need to update your service incrementally without taking the entire service offline at once.</p></li>
     /// <li>
     /// <p>Limited resource requirements: You want to avoid the additional resource costs of running two complete environments simultaneously (as required by blue/green deployments).</p></li>
     /// <li>

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_deployment_ephemeral_storage.rs

@@ -1,1 +107,118 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The amount of ephemeral storage to allocate for the deployment.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct DeploymentEphemeralStorage {
     /// <p>Specify an Key Management Service key ID to encrypt the ephemeral storage for deployment.</p>
     pub kms_key_id: ::std::option::Option<::std::string::String>,
-9
+}
 impl DeploymentEphemeralStorage {
     /// <p>Specify an Key Management Service key ID to encrypt the ephemeral storage for deployment.</p>
     pub fn kms_key_id(&self) -> ::std::option::Option<&str> {
         self.kms_key_id.as_deref()
-14
+    }
-15
+}
 static DEPLOYMENTEPHEMERALSTORAGE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs#DeploymentEphemeralStorage",

     "com.amazonaws.ecs",
     "DeploymentEphemeralStorage",
 );
 static DEPLOYMENTEPHEMERALSTORAGE_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DeploymentEphemeralStorage$kmsKeyId",
         "com.amazonaws.ecs",
         "DeploymentEphemeralStorage",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "kms_key_id",
     "kmsKeyId",
 ,
 );
 static DEPLOYMENTEPHEMERALSTORAGE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DEPLOYMENTEPHEMERALSTORAGE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DEPLOYMENTEPHEMERALSTORAGE_MEMBER_KMS_KEY_ID],
 );
 impl DeploymentEphemeralStorage {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEPLOYMENTEPHEMERALSTORAGE_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeploymentEphemeralStorage {
     #[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.kms_key_id {
             ser.write_string(&DEPLOYMENTEPHEMERALSTORAGE_MEMBER_KMS_KEY_ID, val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl DeploymentEphemeralStorage {
     /// 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(&DEPLOYMENTEPHEMERALSTORAGE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DEPLOYMENTEPHEMERALSTORAGE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.kms_key_id = Some(deser.read_string(member)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl DeploymentEphemeralStorage {
     /// 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 DeploymentEphemeralStorage {
     /// Creates a new builder-style object to manufacture [`DeploymentEphemeralStorage`](crate::types::DeploymentEphemeralStorage).
     pub fn builder() -> crate::types::builders::DeploymentEphemeralStorageBuilder {
         crate::types::builders::DeploymentEphemeralStorageBuilder::default()
-93
+    }
-94
+}
-95
 /// A builder for [`DeploymentEphemeralStorage`](crate::types::DeploymentEphemeralStorage).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DeploymentEphemeralStorageBuilder {
     pub(crate) kms_key_id: ::std::option::Option<::std::string::String>,
-101
+}
 impl DeploymentEphemeralStorageBuilder {
     /// <p>Specify an Key Management Service key ID to encrypt the ephemeral storage for deployment.</p>
     pub fn kms_key_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.kms_key_id = ::std::option::Option::Some(input.into());
         self
-107
+    }
     /// <p>Specify an Key Management Service key ID to encrypt the ephemeral storage for deployment.</p>
     pub fn set_kms_key_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.kms_key_id = input;
         self
-112
+    }
     /// <p>Specify an Key Management Service key ID to encrypt the ephemeral storage for deployment.</p>
     pub fn get_kms_key_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.kms_key_id
-116
+    }
     /// Consumes the builder and constructs a [`DeploymentEphemeralStorage`](crate::types::DeploymentEphemeralStorage).
     pub fn build(self) -> crate::types::DeploymentEphemeralStorage {

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_deployment_lifecycle_hook.rs

@@ -85,85 +265,273 @@

↥ Expand context

     /// <p>Production traffic is shifting to the green service revision. The green service revision is migrating from 0% to 100% of production traffic.</p>
     /// <p>You can use a lifecycle hook for this stage.</p></li>
     /// <li>
     /// <p>POST_PRODUCTION_TRAFFIC_SHIFT</p>
     /// <p>The production traffic shift is complete.</p>
     /// <p>You can use a lifecycle hook for this stage.</p></li>
     /// </ul>
     /// <p>You must provide this parameter when configuring a deployment lifecycle hook.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.lifecycle_stages.is_none()`.
     pub fn lifecycle_stages(&self) -> &[crate::types::DeploymentLifecycleHookStage] {
         self.lifecycle_stages.as_deref().unwrap_or_default()
-97
+    }
     /// <p>Use this field to specify custom parameters that Amazon ECS will pass to your hook target invocations (such as a Lambda function).</p>
     pub fn hook_details(&self) -> ::std::option::Option<&::aws_smithy_types::Document> {
         self.hook_details.as_ref()
-101
+    }
-102
+}
 static DEPLOYMENTLIFECYCLEHOOK_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs#DeploymentLifecycleHook",

     "com.amazonaws.ecs",
     "DeploymentLifecycleHook",
 );
 static DEPLOYMENTLIFECYCLEHOOK_MEMBER_HOOK_TARGET_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DeploymentLifecycleHook$hookTargetArn",
         "com.amazonaws.ecs",
         "DeploymentLifecycleHook",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "hook_target_arn",
     "hookTargetArn",
 ,
 );
 static DEPLOYMENTLIFECYCLEHOOK_MEMBER_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DeploymentLifecycleHook$roleArn",
         "com.amazonaws.ecs",
         "DeploymentLifecycleHook",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "role_arn",
     "roleArn",
 ,
 );
 static DEPLOYMENTLIFECYCLEHOOK_MEMBER_LIFECYCLE_STAGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DeploymentLifecycleHook$lifecycleStages",
         "com.amazonaws.ecs",
         "DeploymentLifecycleHook",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "lifecycle_stages",
     "lifecycleStages",
 ,
 );
 static DEPLOYMENTLIFECYCLEHOOK_MEMBER_HOOK_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DeploymentLifecycleHook$hookDetails",
         "com.amazonaws.ecs",
         "DeploymentLifecycleHook",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "hook_details",
     "hookDetails",
 ,
 );
 static DEPLOYMENTLIFECYCLEHOOK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DEPLOYMENTLIFECYCLEHOOK_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DEPLOYMENTLIFECYCLEHOOK_MEMBER_HOOK_TARGET_ARN,
         &DEPLOYMENTLIFECYCLEHOOK_MEMBER_ROLE_ARN,
         &DEPLOYMENTLIFECYCLEHOOK_MEMBER_LIFECYCLE_STAGES,
         &DEPLOYMENTLIFECYCLEHOOK_MEMBER_HOOK_DETAILS,
     ],
 );
 impl DeploymentLifecycleHook {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEPLOYMENTLIFECYCLEHOOK_SCHEMA;
-161
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DeploymentLifecycleHook {
     #[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.hook_target_arn {
             ser.write_string(&DEPLOYMENTLIFECYCLEHOOK_MEMBER_HOOK_TARGET_ARN, val)?;
-170
+        }
         if let Some(ref val) = self.role_arn {
             ser.write_string(&DEPLOYMENTLIFECYCLEHOOK_MEMBER_ROLE_ARN, val)?;
-173
+        }
         if let Some(ref val) = self.lifecycle_stages {
             ser.write_list(
                 &DEPLOYMENTLIFECYCLEHOOK_MEMBER_LIFECYCLE_STAGES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
-180
+                    }
                     Ok(())
                 },
             )?;
-184
+        }
         if let Some(ref val) = self.hook_details {
             ser.write_document(&DEPLOYMENTLIFECYCLEHOOK_MEMBER_HOOK_DETAILS, val)?;
-187
+        }
         Ok(())
-189
+    }
-190
+}
 impl DeploymentLifecycleHook {
     /// 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(&DEPLOYMENTLIFECYCLEHOOK_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DEPLOYMENTLIFECYCLEHOOK_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.hook_target_arn = Some(deser.read_string(member)?);
-209
+                }
                 Some(1) => {
                     builder.role_arn = Some(deser.read_string(member)?);
-212
+                }
                 Some(2) => {
                     builder.lifecycle_stages = 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::DeploymentLifecycleHookStage::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::DeploymentLifecycleHookStage::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-222
+                }
                 Some(3) => {
                     builder.hook_details = Some(deser.read_document(member)?);
-225
+                }
                 _ => {}
-227
+            }
             Ok(())
         })?;
         Ok(builder.build())
-231
+    }
-232
+}
 impl DeploymentLifecycleHook {
     /// 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 DeploymentLifecycleHook {
     /// Creates a new builder-style object to manufacture [`DeploymentLifecycleHook`](crate::types::DeploymentLifecycleHook).
     pub fn builder() -> crate::types::builders::DeploymentLifecycleHookBuilder {
         crate::types::builders::DeploymentLifecycleHookBuilder::default()
-248
+    }
-249
+}
-250
 /// A builder for [`DeploymentLifecycleHook`](crate::types::DeploymentLifecycleHook).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DeploymentLifecycleHookBuilder {
     pub(crate) hook_target_arn: ::std::option::Option<::std::string::String>,
     pub(crate) role_arn: ::std::option::Option<::std::string::String>,
     pub(crate) lifecycle_stages: ::std::option::Option<::std::vec::Vec<crate::types::DeploymentLifecycleHookStage>>,
     pub(crate) hook_details: ::std::option::Option<::aws_smithy_types::Document>,
-259
+}
 impl DeploymentLifecycleHookBuilder {
     /// <p>The Amazon Resource Name (ARN) of the hook target. Currently, only Lambda function ARNs are supported.</p>
     /// <p>You must provide this parameter when configuring a deployment lifecycle hook.</p>
     pub fn hook_target_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.hook_target_arn = ::std::option::Option::Some(input.into());
         self
-266
+    }
     /// <p>The Amazon Resource Name (ARN) of the hook target. Currently, only Lambda function ARNs are supported.</p>
     /// <p>You must provide this parameter when configuring a deployment lifecycle hook.</p>
     pub fn set_hook_target_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.hook_target_arn = input;
         self
-272
+    }
     /// <p>The Amazon Resource Name (ARN) of the hook target. Currently, only Lambda function ARNs are supported.</p>

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_device.rs

@@ -6,6 +160,169 @@

↥ Expand context

 pub struct Device {
     /// <p>The path for the device on the host container instance.</p>
     pub host_path: ::std::string::String,
     /// <p>The path inside the container at which to expose the host device.</p>
     pub container_path: ::std::option::Option<::std::string::String>,
     /// <p>The explicit permissions to provide to the container for the device. By default, the container has permissions for <code>read</code>, <code>write</code>, and <code>mknod</code> for the device.</p>
     pub permissions: ::std::option::Option<::std::vec::Vec<crate::types::DeviceCgroupPermission>>,
-13
+}
 impl Device {
     /// <p>The path for the device on the host container instance.</p>
     pub fn host_path(&self) -> &str {
         use std::ops::Deref;
         self.host_path.deref()
-19
+    }
     /// <p>The path inside the container at which to expose the host device.</p>
     pub fn container_path(&self) -> ::std::option::Option<&str> {
         self.container_path.as_deref()
-23
+    }
     /// <p>The explicit permissions to provide to the container for the device. By default, the container has permissions for <code>read</code>, <code>write</code>, and <code>mknod</code> for the device.</p>
     ///

     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.permissions.is_none()`.
     pub fn permissions(&self) -> &[crate::types::DeviceCgroupPermission] {
         self.permissions.as_deref().unwrap_or_default()
-29
+    }
-30
+}
 static DEVICE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Device", "com.amazonaws.ecs", "Device");
 static DEVICE_MEMBER_HOST_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Device$hostPath", "com.amazonaws.ecs", "Device"),
     ::aws_smithy_schema::ShapeType::String,
     "host_path",
     "hostPath",
 ,
 );
 static DEVICE_MEMBER_CONTAINER_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Device$containerPath", "com.amazonaws.ecs", "Device"),
     ::aws_smithy_schema::ShapeType::String,
     "container_path",
     "containerPath",
 ,
 );
 static DEVICE_MEMBER_PERMISSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Device$permissions", "com.amazonaws.ecs", "Device"),
     ::aws_smithy_schema::ShapeType::List,
     "permissions",
 ,
 );
 static DEVICE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DEVICE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DEVICE_MEMBER_HOST_PATH, &DEVICE_MEMBER_CONTAINER_PATH, &DEVICE_MEMBER_PERMISSIONS],
 );
 impl Device {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEVICE_SCHEMA;
-59
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Device {
     #[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> {
-66
+        {
             let val = &self.host_path;
             ser.write_string(&DEVICE_MEMBER_HOST_PATH, val)?;
-69
+        }
         if let Some(ref val) = self.container_path {
             ser.write_string(&DEVICE_MEMBER_CONTAINER_PATH, val)?;
-72
+        }
         if let Some(ref val) = self.permissions {
             ser.write_list(
                 &DEVICE_MEMBER_PERMISSIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
-79
+                    }
                     Ok(())
                 },
             )?;
-83
+        }
         Ok(())
-85
+    }
-86
+}
 impl Device {
     /// 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(&DEVICE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DEVICE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.host_path = Some(deser.read_string(member)?);
-105
+                }
                 Some(1) => {
                     builder.container_path = Some(deser.read_string(member)?);
-108
+                }
                 Some(2) => {
                     builder.permissions = 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::DeviceCgroupPermission::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::DeviceCgroupPermission::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-118
+                }
                 _ => {}
-120
+            }
             Ok(())
         })?;
         builder.host_path = builder.host_path.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-127
+    }
-128
+}
 impl Device {
     /// 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 Device {
     /// Creates a new builder-style object to manufacture [`Device`](crate::types::Device).
     pub fn builder() -> crate::types::builders::DeviceBuilder {
         crate::types::builders::DeviceBuilder::default()
-144
+    }
-145
+}
-146
 /// A builder for [`Device`](crate::types::Device).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DeviceBuilder {
     pub(crate) host_path: ::std::option::Option<::std::string::String>,
     pub(crate) container_path: ::std::option::Option<::std::string::String>,
     pub(crate) permissions: ::std::option::Option<::std::vec::Vec<crate::types::DeviceCgroupPermission>>,
-154
+}
 impl DeviceBuilder {
     /// <p>The path for the device on the host container instance.</p>
     /// This field is required.
     pub fn host_path(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.host_path = ::std::option::Option::Some(input.into());
         self
-161
+    }
     /// <p>The path for the device on the host container instance.</p>
     pub fn set_host_path(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.host_path = input;
         self
-166
+    }
     /// <p>The path for the device on the host container instance.</p>
     pub fn get_host_path(&self) -> &::std::option::Option<::std::string::String> {
         &self.host_path

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_docker_volume_configuration.rs

@@ -56,56 +116,116 @@

↥ Expand context

     "scope",
 ,
 );
 static DOCKERVOLUMECONFIGURATION_MEMBER_AUTOPROVISION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DockerVolumeConfiguration$autoprovision",
         "com.amazonaws.ecs",
         "DockerVolumeConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "autoprovision",
 ,
 );
 static DOCKERVOLUMECONFIGURATION_MEMBER_DRIVER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DockerVolumeConfiguration$driver",
         "com.amazonaws.ecs",
         "DockerVolumeConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,

     "driver",
 ,
 );
 static DOCKERVOLUMECONFIGURATION_MEMBER_DRIVER_OPTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DockerVolumeConfiguration$driverOpts",
         "com.amazonaws.ecs",
         "DockerVolumeConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "driver_opts",
     "driverOpts",
 ,
 );
 static DOCKERVOLUMECONFIGURATION_MEMBER_LABELS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#DockerVolumeConfiguration$labels",
         "com.amazonaws.ecs",
         "DockerVolumeConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "labels",

↧ Expand context

 ,
 );
 static DOCKERVOLUMECONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DOCKERVOLUMECONFIGURATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DOCKERVOLUMECONFIGURATION_MEMBER_SCOPE,
         &DOCKERVOLUMECONFIGURATION_MEMBER_AUTOPROVISION,
         &DOCKERVOLUMECONFIGURATION_MEMBER_DRIVER,
         &DOCKERVOLUMECONFIGURATION_MEMBER_DRIVER_OPTS,
         &DOCKERVOLUMECONFIGURATION_MEMBER_LABELS,
     ],
 );
 impl DockerVolumeConfiguration {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DOCKERVOLUMECONFIGURATION_SCHEMA;
-113
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DockerVolumeConfiguration {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(

@@ -128,128 +243,234 @@

↥ Expand context

-128
+        }
         if let Some(ref val) = self.driver_opts {
             ser.write_map(
                 &DOCKERVOLUMECONFIGURATION_MEMBER_DRIVER_OPTS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-136
+                    }
                     Ok(())
                 },
             )?;
-140
+        }
         if let Some(ref val) = self.labels {
             ser.write_map(
                 &DOCKERVOLUMECONFIGURATION_MEMBER_LABELS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;

-148
+                    }
                     Ok(())
                 },
             )?;
-152
+        }
         Ok(())
-154
+    }
-155
+}
 impl DockerVolumeConfiguration {
     /// 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(&DOCKERVOLUMECONFIGURATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DOCKERVOLUMECONFIGURATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.scope = Some(crate::types::Scope::from(deser.read_string(member)?.as_str()));
-174
+                }
                 Some(1) => {
                     builder.autoprovision = Some(deser.read_boolean(member)?);
-177
+                }
                 Some(2) => {
                     builder.driver = Some(deser.read_string(member)?);
-180
+                }
                 Some(3) => {
                     builder.driver_opts = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.driver_opts = Some(deser.read_string_string_map(member)?);
-183
+                }
                 Some(4) => {
                     builder.labels = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.labels = Some(deser.read_string_string_map(member)?);
-186
+                }
                 _ => {}
-188
+            }
             Ok(())
         })?;
         Ok(builder.build())
-192
+    }
-193
+}
 impl DockerVolumeConfiguration {
     /// 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 DockerVolumeConfiguration {
     /// Creates a new builder-style object to manufacture [`DockerVolumeConfiguration`](crate::types::DockerVolumeConfiguration).
     pub fn builder() -> crate::types::builders::DockerVolumeConfigurationBuilder {
         crate::types::builders::DockerVolumeConfigurationBuilder::default()
-209
+    }
-210
+}
-211
 /// A builder for [`DockerVolumeConfiguration`](crate::types::DockerVolumeConfiguration).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DockerVolumeConfigurationBuilder {
     pub(crate) scope: ::std::option::Option<crate::types::Scope>,
     pub(crate) autoprovision: ::std::option::Option<bool>,
     pub(crate) driver: ::std::option::Option<::std::string::String>,
     pub(crate) driver_opts: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) labels: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
-221
+}
 impl DockerVolumeConfigurationBuilder {
     /// <p>The scope for the Docker volume that determines its lifecycle. Docker volumes that are scoped to a <code>task</code> are automatically provisioned when the task starts and destroyed when the task stops. Docker volumes that are scoped as <code>shared</code> persist after the task stops.</p>
     pub fn scope(mut self, input: crate::types::Scope) -> Self {
         self.scope = ::std::option::Option::Some(input);
         self
-227
+    }
     /// <p>The scope for the Docker volume that determines its lifecycle. Docker volumes that are scoped to a <code>task</code> are automatically provisioned when the task starts and destroyed when the task stops. Docker volumes that are scoped as <code>shared</code> persist after the task stops.</p>
     pub fn set_scope(mut self, input: ::std::option::Option<crate::types::Scope>) -> Self {
         self.scope = input;
         self
-232
+    }
     /// <p>The scope for the Docker volume that determines its lifecycle. Docker volumes that are scoped to a <code>task</code> are automatically provisioned when the task starts and destroyed when the task stops. Docker volumes that are scoped as <code>shared</code> persist after the task stops.</p>
     pub fn get_scope(&self) -> &::std::option::Option<crate::types::Scope> {

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_ebs_tag_specification.rs

@@ -9,9 +171,179 @@

↥ Expand context

     /// <p>The tags applied to this Amazon EBS volume. <code>AmazonECSCreated</code> and <code>AmazonECSManaged</code> are reserved tags that can't be used.</p>
     pub tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     /// <p>Determines whether to propagate the tags from the task definition to  the Amazon EBS volume. Tags can only propagate to a <code>SERVICE</code> specified in  <code>ServiceVolumeConfiguration</code>. If no value is specified, the tags aren't  propagated.</p>
     pub propagate_tags: ::std::option::Option<crate::types::PropagateTags>,
-13
+}
 impl EbsTagSpecification {
     /// <p>The type of volume resource.</p>
     pub fn resource_type(&self) -> &crate::types::EbsResourceType {
         &self.resource_type
-18
+    }
     /// <p>The tags applied to this Amazon EBS volume. <code>AmazonECSCreated</code> and <code>AmazonECSManaged</code> are reserved tags that can't be used.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
     pub fn tags(&self) -> &[crate::types::Tag] {
         self.tags.as_deref().unwrap_or_default()
-24
+    }
     /// <p>Determines whether to propagate the tags from the task definition to  the Amazon EBS volume. Tags can only propagate to a <code>SERVICE</code> specified in  <code>ServiceVolumeConfiguration</code>. If no value is specified, the tags aren't  propagated.</p>
     pub fn propagate_tags(&self) -> ::std::option::Option<&crate::types::PropagateTags> {
         self.propagate_tags.as_ref()
-28
+    }

-29
+}
 static EBSTAGSPECIFICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#EBSTagSpecification", "com.amazonaws.ecs", "EBSTagSpecification");
 static EBSTAGSPECIFICATION_MEMBER_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#EBSTagSpecification$resourceType",
         "com.amazonaws.ecs",
         "EBSTagSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_type",
     "resourceType",
 ,
 );
 static EBSTAGSPECIFICATION_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#EBSTagSpecification$tags", "com.amazonaws.ecs", "EBSTagSpecification"),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
 ,
 );
 static EBSTAGSPECIFICATION_MEMBER_PROPAGATE_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#EBSTagSpecification$propagateTags",
         "com.amazonaws.ecs",
         "EBSTagSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "propagate_tags",
     "propagateTags",
 ,
 );
 static EBSTAGSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EBSTAGSPECIFICATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &EBSTAGSPECIFICATION_MEMBER_RESOURCE_TYPE,
         &EBSTAGSPECIFICATION_MEMBER_TAGS,
         &EBSTAGSPECIFICATION_MEMBER_PROPAGATE_TAGS,
     ],
 );
 impl EbsTagSpecification {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EBSTAGSPECIFICATION_SCHEMA;
-70
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EbsTagSpecification {
     #[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> {
-77
+        {
             let val = &self.resource_type;
             ser.write_string(&EBSTAGSPECIFICATION_MEMBER_RESOURCE_TYPE, val.as_str())?;
-80
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &EBSTAGSPECIFICATION_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-87
+                    }
                     Ok(())
                 },
             )?;
-91
+        }
         if let Some(ref val) = self.propagate_tags {
             ser.write_string(&EBSTAGSPECIFICATION_MEMBER_PROPAGATE_TAGS, val.as_str())?;
-94
+        }
         Ok(())
-96
+    }
-97
+}
 impl EbsTagSpecification {
     /// 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(&EBSTAGSPECIFICATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EBSTAGSPECIFICATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_type = Some(crate::types::EbsResourceType::from(deser.read_string(member)?.as_str()));
-116
+                }
                 Some(1) => {
                     builder.tags = 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::Tag::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-126
+                }
                 Some(2) => {
                     builder.propagate_tags = Some(crate::types::PropagateTags::from(deser.read_string(member)?.as_str()));
-129
+                }
                 _ => {}
-131
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-137
+    }
-138
+}
 impl EbsTagSpecification {
     /// 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 EbsTagSpecification {
     /// Creates a new builder-style object to manufacture [`EbsTagSpecification`](crate::types::EbsTagSpecification).
     pub fn builder() -> crate::types::builders::EbsTagSpecificationBuilder {
         crate::types::builders::EbsTagSpecificationBuilder::default()
-154
+    }
-155
+}
-156
 /// A builder for [`EbsTagSpecification`](crate::types::EbsTagSpecification).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EbsTagSpecificationBuilder {
     pub(crate) resource_type: ::std::option::Option<crate::types::EbsResourceType>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) propagate_tags: ::std::option::Option<crate::types::PropagateTags>,
-164
+}
 impl EbsTagSpecificationBuilder {
     /// <p>The type of volume resource.</p>
     /// This field is required.
     pub fn resource_type(mut self, input: crate::types::EbsResourceType) -> Self {
         self.resource_type = ::std::option::Option::Some(input);
         self
-171
+    }
     /// <p>The type of volume resource.</p>
     pub fn set_resource_type(mut self, input: ::std::option::Option<crate::types::EbsResourceType>) -> Self {
         self.resource_type = input;
         self
-176
+    }
     /// <p>The type of volume resource.</p>
     pub fn get_resource_type(&self) -> &::std::option::Option<crate::types::EbsResourceType> {
         &self.resource_type

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_efs_authorization_config.rs

@@ -1,1 +126,137 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The authorization configuration details for the Amazon EFS file system.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct EfsAuthorizationConfig {
     /// <p>The Amazon EFS access point ID to use. If an access point is specified, the root directory value specified in the <code>EFSVolumeConfiguration</code> must either be omitted or set to <code>/</code> which will enforce the path set on the EFS access point. If an access point is used, transit encryption must be on in the <code>EFSVolumeConfiguration</code>. For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html">Working with Amazon EFS access points</a> in the <i>Amazon Elastic File System User Guide</i>.</p>
     pub access_point_id: ::std::option::Option<::std::string::String>,
     /// <p>Determines whether to use the Amazon ECS task role defined in a task definition when mounting the Amazon EFS file system. If it is turned on, transit encryption must be turned on in the <code>EFSVolumeConfiguration</code>. If this parameter is omitted, the default value of <code>DISABLED</code> is used. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html#efs-volume-accesspoints">Using Amazon EFS access points</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
     pub iam: ::std::option::Option<crate::types::EfsAuthorizationConfigIam>,
-11
+}
 impl EfsAuthorizationConfig {
     /// <p>The Amazon EFS access point ID to use. If an access point is specified, the root directory value specified in the <code>EFSVolumeConfiguration</code> must either be omitted or set to <code>/</code> which will enforce the path set on the EFS access point. If an access point is used, transit encryption must be on in the <code>EFSVolumeConfiguration</code>. For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html">Working with Amazon EFS access points</a> in the <i>Amazon Elastic File System User Guide</i>.</p>
     pub fn access_point_id(&self) -> ::std::option::Option<&str> {
         self.access_point_id.as_deref()
-16
+    }
     /// <p>Determines whether to use the Amazon ECS task role defined in a task definition when mounting the Amazon EFS file system. If it is turned on, transit encryption must be turned on in the <code>EFSVolumeConfiguration</code>. If this parameter is omitted, the default value of <code>DISABLED</code> is used. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html#efs-volume-accesspoints">Using Amazon EFS access points</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
     pub fn iam(&self) -> ::std::option::Option<&crate::types::EfsAuthorizationConfigIam> {
         self.iam.as_ref()
-20
+    }

-21
+}
 static EFSAUTHORIZATIONCONFIG_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#EFSAuthorizationConfig", "com.amazonaws.ecs", "EFSAuthorizationConfig");
 static EFSAUTHORIZATIONCONFIG_MEMBER_ACCESS_POINT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#EFSAuthorizationConfig$accessPointId",
         "com.amazonaws.ecs",
         "EFSAuthorizationConfig",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "access_point_id",
     "accessPointId",
 ,
 );
 static EFSAUTHORIZATIONCONFIG_MEMBER_IAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#EFSAuthorizationConfig$iam",
         "com.amazonaws.ecs",
         "EFSAuthorizationConfig",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "iam",
 ,
 );
 static EFSAUTHORIZATIONCONFIG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EFSAUTHORIZATIONCONFIG_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&EFSAUTHORIZATIONCONFIG_MEMBER_ACCESS_POINT_ID, &EFSAUTHORIZATIONCONFIG_MEMBER_IAM],
 );
 impl EfsAuthorizationConfig {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EFSAUTHORIZATIONCONFIG_SCHEMA;
-52
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EfsAuthorizationConfig {
     #[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.access_point_id {
             ser.write_string(&EFSAUTHORIZATIONCONFIG_MEMBER_ACCESS_POINT_ID, val)?;
-61
+        }
         if let Some(ref val) = self.iam {
             ser.write_string(&EFSAUTHORIZATIONCONFIG_MEMBER_IAM, val.as_str())?;
-64
+        }
         Ok(())
-66
+    }
-67
+}
 impl EfsAuthorizationConfig {
     /// 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(&EFSAUTHORIZATIONCONFIG_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EFSAUTHORIZATIONCONFIG_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.access_point_id = Some(deser.read_string(member)?);
-86
+                }
                 Some(1) => {
                     builder.iam = Some(crate::types::EfsAuthorizationConfigIam::from(deser.read_string(member)?.as_str()));
-89
+                }
                 _ => {}
-91
+            }
             Ok(())
         })?;
         Ok(builder.build())
-95
+    }
-96
+}
 impl EfsAuthorizationConfig {
     /// 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 EfsAuthorizationConfig {
     /// Creates a new builder-style object to manufacture [`EfsAuthorizationConfig`](crate::types::EfsAuthorizationConfig).
     pub fn builder() -> crate::types::builders::EfsAuthorizationConfigBuilder {
         crate::types::builders::EfsAuthorizationConfigBuilder::default()
-112
+    }
-113
+}
-114
 /// A builder for [`EfsAuthorizationConfig`](crate::types::EfsAuthorizationConfig).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EfsAuthorizationConfigBuilder {
     pub(crate) access_point_id: ::std::option::Option<::std::string::String>,
     pub(crate) iam: ::std::option::Option<crate::types::EfsAuthorizationConfigIam>,
-121
+}
 impl EfsAuthorizationConfigBuilder {
     /// <p>The Amazon EFS access point ID to use. If an access point is specified, the root directory value specified in the <code>EFSVolumeConfiguration</code> must either be omitted or set to <code>/</code> which will enforce the path set on the EFS access point. If an access point is used, transit encryption must be on in the <code>EFSVolumeConfiguration</code>. For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html">Working with Amazon EFS access points</a> in the <i>Amazon Elastic File System User Guide</i>.</p>
     pub fn access_point_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.access_point_id = ::std::option::Option::Some(input.into());
         self
-127
+    }
     /// <p>The Amazon EFS access point ID to use. If an access point is specified, the root directory value specified in the <code>EFSVolumeConfiguration</code> must either be omitted or set to <code>/</code> which will enforce the path set on the EFS access point. If an access point is used, transit encryption must be on in the <code>EFSVolumeConfiguration</code>. For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html">Working with Amazon EFS access points</a> in the <i>Amazon Elastic File System User Guide</i>.</p>
     pub fn set_access_point_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.access_point_id = input;
         self
-132
+    }
     /// <p>The Amazon EFS access point ID to use. If an access point is specified, the root directory value specified in the <code>EFSVolumeConfiguration</code> must either be omitted or set to <code>/</code> which will enforce the path set on the EFS access point. If an access point is used, transit encryption must be on in the <code>EFSVolumeConfiguration</code>. For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html">Working with Amazon EFS access points</a> in the <i>Amazon Elastic File System User Guide</i>.</p>
     pub fn get_access_point_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.access_point_id
-136
+    }
     /// <p>Determines whether to use the Amazon ECS task role defined in a task definition when mounting the Amazon EFS file system. If it is turned on, transit encryption must be turned on in the <code>EFSVolumeConfiguration</code>. If this parameter is omitted, the default value of <code>DISABLED</code> is used. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html#efs-volume-accesspoints">Using Amazon EFS access points</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_efs_volume_configuration.rs

@@ -24,24 +206,218 @@

↥ Expand context

         self.file_system_id.deref()
-25
+    }
     /// <p>The directory within the Amazon EFS file system to mount as the root directory inside the host. If this parameter is omitted, the root of the Amazon EFS volume will be used. Specifying <code>/</code> will have the same effect as omitting this parameter.</p><important>
     /// <p>If an EFS access point is specified in the <code>authorizationConfig</code>, the root directory parameter must either be omitted or set to <code>/</code> which will enforce the path set on the EFS access point.</p>
     /// </important>
     pub fn root_directory(&self) -> ::std::option::Option<&str> {
         self.root_directory.as_deref()
-31
+    }
     /// <p>Determines whether to use encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server. Transit encryption must be turned on if Amazon EFS IAM authorization is used. If this parameter is omitted, the default value of <code>DISABLED</code> is used. For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html">Encrypting data in transit</a> in the <i>Amazon Elastic File System User Guide</i>.</p>
     pub fn transit_encryption(&self) -> ::std::option::Option<&crate::types::EfsTransitEncryption> {
         self.transit_encryption.as_ref()
-35
+    }
     /// <p>The port to use when sending encrypted data between the Amazon ECS host and the Amazon EFS server. If you do not specify a transit encryption port, it will use the port selection strategy that the Amazon EFS mount helper uses. For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/efs-mount-helper.html">EFS mount helper</a> in the <i>Amazon Elastic File System User Guide</i>.</p>
     pub fn transit_encryption_port(&self) -> ::std::option::Option<i32> {
         self.transit_encryption_port
-39
+    }
     /// <p>The authorization configuration details for the Amazon EFS file system.</p>
     pub fn authorization_config(&self) -> ::std::option::Option<&crate::types::EfsAuthorizationConfig> {
         self.authorization_config.as_ref()
-43
+    }

-44
+}
 static EFSVOLUMECONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#EFSVolumeConfiguration", "com.amazonaws.ecs", "EFSVolumeConfiguration");
 static EFSVOLUMECONFIGURATION_MEMBER_FILE_SYSTEM_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#EFSVolumeConfiguration$fileSystemId",
         "com.amazonaws.ecs",
         "EFSVolumeConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "file_system_id",
     "fileSystemId",
 ,
 );
 static EFSVOLUMECONFIGURATION_MEMBER_ROOT_DIRECTORY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#EFSVolumeConfiguration$rootDirectory",
         "com.amazonaws.ecs",
         "EFSVolumeConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "root_directory",
     "rootDirectory",
 ,
 );
 static EFSVOLUMECONFIGURATION_MEMBER_TRANSIT_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#EFSVolumeConfiguration$transitEncryption",
         "com.amazonaws.ecs",
         "EFSVolumeConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "transit_encryption",
     "transitEncryption",
 ,
 );
 static EFSVOLUMECONFIGURATION_MEMBER_TRANSIT_ENCRYPTION_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#EFSVolumeConfiguration$transitEncryptionPort",
         "com.amazonaws.ecs",
         "EFSVolumeConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "transit_encryption_port",
     "transitEncryptionPort",
 ,
 );
 static EFSVOLUMECONFIGURATION_MEMBER_AUTHORIZATION_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#EFSVolumeConfiguration$authorizationConfig",
         "com.amazonaws.ecs",
         "EFSVolumeConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "authorization_config",
     "authorizationConfig",
 ,
 );
 static EFSVOLUMECONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EFSVOLUMECONFIGURATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &EFSVOLUMECONFIGURATION_MEMBER_FILE_SYSTEM_ID,
         &EFSVOLUMECONFIGURATION_MEMBER_ROOT_DIRECTORY,
         &EFSVOLUMECONFIGURATION_MEMBER_TRANSIT_ENCRYPTION,
         &EFSVOLUMECONFIGURATION_MEMBER_TRANSIT_ENCRYPTION_PORT,
         &EFSVOLUMECONFIGURATION_MEMBER_AUTHORIZATION_CONFIG,
     ],
 );
 impl EfsVolumeConfiguration {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EFSVOLUMECONFIGURATION_SCHEMA;
-111
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EfsVolumeConfiguration {
     #[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> {
-118
+        {
             let val = &self.file_system_id;
             ser.write_string(&EFSVOLUMECONFIGURATION_MEMBER_FILE_SYSTEM_ID, val)?;
-121
+        }
         if let Some(ref val) = self.root_directory {
             ser.write_string(&EFSVOLUMECONFIGURATION_MEMBER_ROOT_DIRECTORY, val)?;
-124
+        }
         if let Some(ref val) = self.transit_encryption {
             ser.write_string(&EFSVOLUMECONFIGURATION_MEMBER_TRANSIT_ENCRYPTION, val.as_str())?;
-127
+        }
         if let Some(ref val) = self.transit_encryption_port {
             ser.write_integer(&EFSVOLUMECONFIGURATION_MEMBER_TRANSIT_ENCRYPTION_PORT, *val)?;
-130
+        }
         if let Some(ref val) = self.authorization_config {
             ser.write_struct(&EFSVOLUMECONFIGURATION_MEMBER_AUTHORIZATION_CONFIG, val)?;
-133
+        }
         Ok(())
-135
+    }
-136
+}
 impl EfsVolumeConfiguration {
     /// 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(&EFSVOLUMECONFIGURATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EFSVOLUMECONFIGURATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.file_system_id = Some(deser.read_string(member)?);
-155
+                }
                 Some(1) => {
                     builder.root_directory = Some(deser.read_string(member)?);
-158
+                }
                 Some(2) => {
                     builder.transit_encryption = Some(crate::types::EfsTransitEncryption::from(deser.read_string(member)?.as_str()));
-161
+                }
                 Some(3) => {
                     builder.transit_encryption_port = Some(deser.read_integer(member)?);
-164
+                }
                 Some(4) => {
                     builder.authorization_config = Some(crate::types::EfsAuthorizationConfig::deserialize(deser)?);
-167
+                }
                 _ => {}
-169
+            }
             Ok(())
         })?;
         builder.file_system_id = builder.file_system_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-176
+    }
-177
+}
 impl EfsVolumeConfiguration {
     /// 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 EfsVolumeConfiguration {
     /// Creates a new builder-style object to manufacture [`EfsVolumeConfiguration`](crate::types::EfsVolumeConfiguration).
     pub fn builder() -> crate::types::builders::EfsVolumeConfigurationBuilder {
         crate::types::builders::EfsVolumeConfigurationBuilder::default()
-193
+    }
-194
+}
-195
 /// A builder for [`EfsVolumeConfiguration`](crate::types::EfsVolumeConfiguration).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EfsVolumeConfigurationBuilder {
     pub(crate) file_system_id: ::std::option::Option<::std::string::String>,
     pub(crate) root_directory: ::std::option::Option<::std::string::String>,
     pub(crate) transit_encryption: ::std::option::Option<crate::types::EfsTransitEncryption>,
     pub(crate) transit_encryption_port: ::std::option::Option<i32>,
     pub(crate) authorization_config: ::std::option::Option<crate::types::EfsAuthorizationConfig>,
-205
+}
 impl EfsVolumeConfigurationBuilder {
     /// <p>The Amazon EFS file system ID to use.</p>
     /// This field is required.
     pub fn file_system_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.file_system_id = ::std::option::Option::Some(input.into());
         self
-212
+    }
     /// <p>The Amazon EFS file system ID to use.</p>
     pub fn set_file_system_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.file_system_id = input;
         self
-217
+    }
     /// <p>The Amazon EFS file system ID to use.</p>

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_environment_file.rs

@@ -22,22 +141,153 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct EnvironmentFile {
     /// <p>The Amazon Resource Name (ARN) of the Amazon S3 object containing the environment variable file.</p>
     pub value: ::std::string::String,
     /// <p>The file type to use. Environment files are objects in Amazon S3. The only supported value is <code>s3</code>.</p>
     pub r#type: crate::types::EnvironmentFileType,
-29
+}
 impl EnvironmentFile {
     /// <p>The Amazon Resource Name (ARN) of the Amazon S3 object containing the environment variable file.</p>
     pub fn value(&self) -> &str {
         use std::ops::Deref;
         self.value.deref()
-35
+    }
     /// <p>The file type to use. Environment files are objects in Amazon S3. The only supported value is <code>s3</code>.</p>
     pub fn r#type(&self) -> &crate::types::EnvironmentFileType {
         &self.r#type
-39
+    }
-40
+}
 static ENVIRONMENTFILE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =

     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#EnvironmentFile", "com.amazonaws.ecs", "EnvironmentFile");
 static ENVIRONMENTFILE_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#EnvironmentFile$value", "com.amazonaws.ecs", "EnvironmentFile"),
     ::aws_smithy_schema::ShapeType::String,
     "value",
 ,
 );
 static ENVIRONMENTFILE_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#EnvironmentFile$type", "com.amazonaws.ecs", "EnvironmentFile"),
     ::aws_smithy_schema::ShapeType::String,
     "r##type",
     "type",
 ,
 );
 static ENVIRONMENTFILE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ENVIRONMENTFILE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ENVIRONMENTFILE_MEMBER_VALUE, &ENVIRONMENTFILE_MEMBER_TYPE],
 );
 impl EnvironmentFile {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ENVIRONMENTFILE_SCHEMA;
-63
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EnvironmentFile {
     #[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> {
-70
+        {
             let val = &self.value;
             ser.write_string(&ENVIRONMENTFILE_MEMBER_VALUE, val)?;
-73
+        }
-74
+        {
             let val = &self.r#type;
             ser.write_string(&ENVIRONMENTFILE_MEMBER_TYPE, val.as_str())?;
-77
+        }
         Ok(())
-79
+    }
-80
+}
 impl EnvironmentFile {
     /// 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(&ENVIRONMENTFILE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ENVIRONMENTFILE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.value = Some(deser.read_string(member)?);
-99
+                }
                 Some(1) => {
                     builder.r#type = Some(crate::types::EnvironmentFileType::from(deser.read_string(member)?.as_str()));
-102
+                }
                 _ => {}
-104
+            }
             Ok(())
         })?;
         builder.value = builder.value.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-111
+    }
-112
+}
 impl EnvironmentFile {
     /// 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 EnvironmentFile {
     /// Creates a new builder-style object to manufacture [`EnvironmentFile`](crate::types::EnvironmentFile).
     pub fn builder() -> crate::types::builders::EnvironmentFileBuilder {
         crate::types::builders::EnvironmentFileBuilder::default()
-128
+    }
-129
+}
-130
 /// A builder for [`EnvironmentFile`](crate::types::EnvironmentFile).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EnvironmentFileBuilder {
     pub(crate) value: ::std::option::Option<::std::string::String>,
     pub(crate) r#type: ::std::option::Option<crate::types::EnvironmentFileType>,
-137
+}
 impl EnvironmentFileBuilder {
     /// <p>The Amazon Resource Name (ARN) of the Amazon S3 object containing the environment variable file.</p>
     /// This field is required.
     pub fn value(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.value = ::std::option::Option::Some(input.into());
         self
-144
+    }
     /// <p>The Amazon Resource Name (ARN) of the Amazon S3 object containing the environment variable file.</p>
     pub fn set_value(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.value = input;
         self
-149
+    }
     /// <p>The Amazon Resource Name (ARN) of the Amazon S3 object containing the environment variable file.</p>
     pub fn get_value(&self) -> &::std::option::Option<::std::string::String> {
         &self.value
-153
+    }

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_ephemeral_storage.rs

@@ -1,1 +109,120 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The amount of ephemeral storage to allocate for the task. This parameter is used to expand the total amount of ephemeral storage available, beyond the default amount, for tasks hosted on Fargate. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html">Using data volumes in tasks</a> in the <i>Amazon ECS Developer Guide;</i>.</p><note>
 /// <p>For tasks using the Fargate launch type, the task requires the following platforms:</p>
 /// <ul>
 /// <li>
 /// <p>Linux platform version <code>1.4.0</code> or later.</p></li>
 /// <li>
 /// <p>Windows platform version <code>1.0.0</code> or later.</p></li>
 /// </ul>
 /// </note>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct EphemeralStorage {
     /// <p>The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is <code>21</code> GiB and the maximum supported value is <code>200</code> GiB.</p>
     pub size_in_gib: i32,
-17
+}
 impl EphemeralStorage {

     /// <p>The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is <code>21</code> GiB and the maximum supported value is <code>200</code> GiB.</p>
     pub fn size_in_gib(&self) -> i32 {
         self.size_in_gib
-22
+    }
-23
+}
 static EPHEMERALSTORAGE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#EphemeralStorage", "com.amazonaws.ecs", "EphemeralStorage");
 static EPHEMERALSTORAGE_MEMBER_SIZE_IN_GIB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#EphemeralStorage$sizeInGiB", "com.amazonaws.ecs", "EphemeralStorage"),
     ::aws_smithy_schema::ShapeType::Integer,
     "size_in_gib",
     "sizeInGiB",
 ,
 );
 static EPHEMERALSTORAGE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EPHEMERALSTORAGE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&EPHEMERALSTORAGE_MEMBER_SIZE_IN_GIB],
 );
 impl EphemeralStorage {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EPHEMERALSTORAGE_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EphemeralStorage {
     #[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> {
-47
+        {
             let val = &self.size_in_gib;
             ser.write_integer(&EPHEMERALSTORAGE_MEMBER_SIZE_IN_GIB, *val)?;
-50
+        }
         Ok(())
-52
+    }
-53
+}
 impl EphemeralStorage {
     /// 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(&EPHEMERALSTORAGE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EPHEMERALSTORAGE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.size_in_gib = Some(deser.read_integer(member)?);
-72
+                }
                 _ => {}
-74
+            }
             Ok(())
         })?;
         Ok(builder.build())
-78
+    }
-79
+}
 impl EphemeralStorage {
     /// 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 EphemeralStorage {
     /// Creates a new builder-style object to manufacture [`EphemeralStorage`](crate::types::EphemeralStorage).
     pub fn builder() -> crate::types::builders::EphemeralStorageBuilder {
         crate::types::builders::EphemeralStorageBuilder::default()
-95
+    }
-96
+}
-97
 /// A builder for [`EphemeralStorage`](crate::types::EphemeralStorage).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EphemeralStorageBuilder {
     pub(crate) size_in_gib: ::std::option::Option<i32>,
-103
+}
 impl EphemeralStorageBuilder {
     /// <p>The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is <code>21</code> GiB and the maximum supported value is <code>200</code> GiB.</p>
     /// This field is required.
     pub fn size_in_gib(mut self, input: i32) -> Self {
         self.size_in_gib = ::std::option::Option::Some(input);
         self
-110
+    }
     /// <p>The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is <code>21</code> GiB and the maximum supported value is <code>200</code> GiB.</p>
     pub fn set_size_in_gib(mut self, input: ::std::option::Option<i32>) -> Self {
         self.size_in_gib = input;
         self
-115
+    }
     /// <p>The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is <code>21</code> GiB and the maximum supported value is <code>200</code> GiB.</p>
     pub fn get_size_in_gib(&self) -> &::std::option::Option<i32> {
         &self.size_in_gib
-119
+    }
     /// Consumes the builder and constructs a [`EphemeralStorage`](crate::types::EphemeralStorage).

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_execute_command_configuration.rs

@@ -26,26 +171,182 @@

↥ Expand context

-26
+    }
     /// <p>The log setting to use for redirecting logs for your execute command results. The following log settings are available.</p>
     /// <ul>
     /// <li>
     /// <p><code>NONE</code>: The execute command session is not logged.</p></li>
     /// <li>
     /// <p><code>DEFAULT</code>: The <code>awslogs</code> configuration in the task definition is used. If no logging parameter is specified, it defaults to this value. If no <code>awslogs</code> log driver is configured in the task definition, the output won't be logged.</p></li>
     /// <li>
     /// <p><code>OVERRIDE</code>: Specify the logging details as a part of <code>logConfiguration</code>. If the <code>OVERRIDE</code> logging option is specified, the <code>logConfiguration</code> is required.</p></li>
     /// </ul>
     pub fn logging(&self) -> ::std::option::Option<&crate::types::ExecuteCommandLogging> {
         self.logging.as_ref()
-38
+    }
     /// <p>The log configuration for the results of the execute command actions. The logs can be sent to CloudWatch Logs or an Amazon S3 bucket. When <code>logging=OVERRIDE</code> is specified, a <code>logConfiguration</code> must be provided.</p>
     pub fn log_configuration(&self) -> ::std::option::Option<&crate::types::ExecuteCommandLogConfiguration> {
         self.log_configuration.as_ref()
-42
+    }
-43
+}
 static EXECUTECOMMANDCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs#ExecuteCommandConfiguration",

     "com.amazonaws.ecs",
     "ExecuteCommandConfiguration",
 );
 static EXECUTECOMMANDCONFIGURATION_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#ExecuteCommandConfiguration$kmsKeyId",
         "com.amazonaws.ecs",
         "ExecuteCommandConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "kms_key_id",
     "kmsKeyId",
 ,
 );
 static EXECUTECOMMANDCONFIGURATION_MEMBER_LOGGING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#ExecuteCommandConfiguration$logging",
         "com.amazonaws.ecs",
         "ExecuteCommandConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "logging",
 ,
 );
 static EXECUTECOMMANDCONFIGURATION_MEMBER_LOG_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#ExecuteCommandConfiguration$logConfiguration",
         "com.amazonaws.ecs",
         "ExecuteCommandConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "log_configuration",
     "logConfiguration",
 ,
 );
 static EXECUTECOMMANDCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EXECUTECOMMANDCONFIGURATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &EXECUTECOMMANDCONFIGURATION_MEMBER_KMS_KEY_ID,
         &EXECUTECOMMANDCONFIGURATION_MEMBER_LOGGING,
         &EXECUTECOMMANDCONFIGURATION_MEMBER_LOG_CONFIGURATION,
     ],
 );
 impl ExecuteCommandConfiguration {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXECUTECOMMANDCONFIGURATION_SCHEMA;
-91
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ExecuteCommandConfiguration {
     #[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.kms_key_id {
             ser.write_string(&EXECUTECOMMANDCONFIGURATION_MEMBER_KMS_KEY_ID, val)?;
-100
+        }
         if let Some(ref val) = self.logging {
             ser.write_string(&EXECUTECOMMANDCONFIGURATION_MEMBER_LOGGING, val.as_str())?;
-103
+        }
         if let Some(ref val) = self.log_configuration {
             ser.write_struct(&EXECUTECOMMANDCONFIGURATION_MEMBER_LOG_CONFIGURATION, val)?;
-106
+        }
         Ok(())
-108
+    }
-109
+}
 impl ExecuteCommandConfiguration {
     /// 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(&EXECUTECOMMANDCONFIGURATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EXECUTECOMMANDCONFIGURATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.kms_key_id = Some(deser.read_string(member)?);
-128
+                }
                 Some(1) => {
                     builder.logging = Some(crate::types::ExecuteCommandLogging::from(deser.read_string(member)?.as_str()));
-131
+                }
                 Some(2) => {
                     builder.log_configuration = Some(crate::types::ExecuteCommandLogConfiguration::deserialize(deser)?);
-134
+                }
                 _ => {}
-136
+            }
             Ok(())
         })?;
         Ok(builder.build())
-140
+    }
-141
+}
 impl ExecuteCommandConfiguration {
     /// 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 ExecuteCommandConfiguration {
     /// Creates a new builder-style object to manufacture [`ExecuteCommandConfiguration`](crate::types::ExecuteCommandConfiguration).
     pub fn builder() -> crate::types::builders::ExecuteCommandConfigurationBuilder {
         crate::types::builders::ExecuteCommandConfigurationBuilder::default()
-157
+    }
-158
+}
-159
 /// A builder for [`ExecuteCommandConfiguration`](crate::types::ExecuteCommandConfiguration).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ExecuteCommandConfigurationBuilder {
     pub(crate) kms_key_id: ::std::option::Option<::std::string::String>,
     pub(crate) logging: ::std::option::Option<crate::types::ExecuteCommandLogging>,
     pub(crate) log_configuration: ::std::option::Option<crate::types::ExecuteCommandLogConfiguration>,
-167
+}
 impl ExecuteCommandConfigurationBuilder {
     /// <p>Specify an Key Management Service key ID to encrypt the data between the local client and the container.</p>
     pub fn kms_key_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.kms_key_id = ::std::option::Option::Some(input.into());
         self
-173
+    }
     /// <p>Specify an Key Management Service key ID to encrypt the data between the local client and the container.</p>
     pub fn set_kms_key_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.kms_key_id = input;
         self
-178
+    }
     /// <p>Specify an Key Management Service key ID to encrypt the data between the local client and the container.</p>
     pub fn get_kms_key_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.kms_key_id
-182
+    }

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_execute_command_log_configuration.rs

@@ -30,30 +211,222 @@

↥ Expand context

     pub fn cloud_watch_encryption_enabled(&self) -> bool {
         self.cloud_watch_encryption_enabled
-32
+    }
     /// <p>The name of the S3 bucket to send logs to.</p><note>
     /// <p>The S3 bucket must already be created.</p>
     /// </note>
     pub fn s3_bucket_name(&self) -> ::std::option::Option<&str> {
         self.s3_bucket_name.as_deref()
-38
+    }
     /// <p>Determines whether to use encryption on the S3 logs. If not specified, encryption is not used.</p>
     pub fn s3_encryption_enabled(&self) -> bool {
         self.s3_encryption_enabled
-42
+    }
     /// <p>An optional folder in the S3 bucket to place logs in.</p>
     pub fn s3_key_prefix(&self) -> ::std::option::Option<&str> {
         self.s3_key_prefix.as_deref()
-46
+    }
-47
+}
 static EXECUTECOMMANDLOGCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs#ExecuteCommandLogConfiguration",

     "com.amazonaws.ecs",
     "ExecuteCommandLogConfiguration",
 );
 static EXECUTECOMMANDLOGCONFIGURATION_MEMBER_CLOUD_WATCH_LOG_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#ExecuteCommandLogConfiguration$cloudWatchLogGroupName",
         "com.amazonaws.ecs",
         "ExecuteCommandLogConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "cloud_watch_log_group_name",
     "cloudWatchLogGroupName",
 ,
 );
 static EXECUTECOMMANDLOGCONFIGURATION_MEMBER_CLOUD_WATCH_ENCRYPTION_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#ExecuteCommandLogConfiguration$cloudWatchEncryptionEnabled",
         "com.amazonaws.ecs",
         "ExecuteCommandLogConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "cloud_watch_encryption_enabled",
     "cloudWatchEncryptionEnabled",
 ,
 );
 static EXECUTECOMMANDLOGCONFIGURATION_MEMBER_S3_BUCKET_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#ExecuteCommandLogConfiguration$s3BucketName",
         "com.amazonaws.ecs",
         "ExecuteCommandLogConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "s3_bucket_name",
     "s3BucketName",
 ,
 );
 static EXECUTECOMMANDLOGCONFIGURATION_MEMBER_S3_ENCRYPTION_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#ExecuteCommandLogConfiguration$s3EncryptionEnabled",
         "com.amazonaws.ecs",
         "ExecuteCommandLogConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "s3_encryption_enabled",
     "s3EncryptionEnabled",
 ,
 );
 static EXECUTECOMMANDLOGCONFIGURATION_MEMBER_S3_KEY_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#ExecuteCommandLogConfiguration$s3KeyPrefix",
         "com.amazonaws.ecs",
         "ExecuteCommandLogConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "s3_key_prefix",
     "s3KeyPrefix",
 ,
 );
 static EXECUTECOMMANDLOGCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EXECUTECOMMANDLOGCONFIGURATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &EXECUTECOMMANDLOGCONFIGURATION_MEMBER_CLOUD_WATCH_LOG_GROUP_NAME,
         &EXECUTECOMMANDLOGCONFIGURATION_MEMBER_CLOUD_WATCH_ENCRYPTION_ENABLED,
         &EXECUTECOMMANDLOGCONFIGURATION_MEMBER_S3_BUCKET_NAME,
         &EXECUTECOMMANDLOGCONFIGURATION_MEMBER_S3_ENCRYPTION_ENABLED,
         &EXECUTECOMMANDLOGCONFIGURATION_MEMBER_S3_KEY_PREFIX,
     ],
 );
 impl ExecuteCommandLogConfiguration {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXECUTECOMMANDLOGCONFIGURATION_SCHEMA;
-117
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ExecuteCommandLogConfiguration {
     #[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.cloud_watch_log_group_name {
             ser.write_string(&EXECUTECOMMANDLOGCONFIGURATION_MEMBER_CLOUD_WATCH_LOG_GROUP_NAME, val)?;
-126
+        }
-127
+        {
             let val = &self.cloud_watch_encryption_enabled;
             ser.write_boolean(&EXECUTECOMMANDLOGCONFIGURATION_MEMBER_CLOUD_WATCH_ENCRYPTION_ENABLED, *val)?;
-130
+        }
         if let Some(ref val) = self.s3_bucket_name {
             ser.write_string(&EXECUTECOMMANDLOGCONFIGURATION_MEMBER_S3_BUCKET_NAME, val)?;
-133
+        }
-134
+        {
             let val = &self.s3_encryption_enabled;
             ser.write_boolean(&EXECUTECOMMANDLOGCONFIGURATION_MEMBER_S3_ENCRYPTION_ENABLED, *val)?;
-137
+        }
         if let Some(ref val) = self.s3_key_prefix {
             ser.write_string(&EXECUTECOMMANDLOGCONFIGURATION_MEMBER_S3_KEY_PREFIX, val)?;
-140
+        }
         Ok(())
-142
+    }
-143
+}
 impl ExecuteCommandLogConfiguration {
     /// 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(&EXECUTECOMMANDLOGCONFIGURATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EXECUTECOMMANDLOGCONFIGURATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cloud_watch_log_group_name = Some(deser.read_string(member)?);
-162
+                }
                 Some(1) => {
                     builder.cloud_watch_encryption_enabled = Some(deser.read_boolean(member)?);
-165
+                }
                 Some(2) => {
                     builder.s3_bucket_name = Some(deser.read_string(member)?);
-168
+                }
                 Some(3) => {
                     builder.s3_encryption_enabled = Some(deser.read_boolean(member)?);
-171
+                }
                 Some(4) => {
                     builder.s3_key_prefix = Some(deser.read_string(member)?);
-174
+                }
                 _ => {}
-176
+            }
             Ok(())
         })?;
         Ok(builder.build())
-180
+    }
-181
+}
 impl ExecuteCommandLogConfiguration {
     /// 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 ExecuteCommandLogConfiguration {
     /// Creates a new builder-style object to manufacture [`ExecuteCommandLogConfiguration`](crate::types::ExecuteCommandLogConfiguration).
     pub fn builder() -> crate::types::builders::ExecuteCommandLogConfigurationBuilder {
         crate::types::builders::ExecuteCommandLogConfigurationBuilder::default()
-197
+    }
-198
+}
-199
 /// A builder for [`ExecuteCommandLogConfiguration`](crate::types::ExecuteCommandLogConfiguration).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ExecuteCommandLogConfigurationBuilder {
     pub(crate) cloud_watch_log_group_name: ::std::option::Option<::std::string::String>,
     pub(crate) cloud_watch_encryption_enabled: ::std::option::Option<bool>,
     pub(crate) s3_bucket_name: ::std::option::Option<::std::string::String>,
     pub(crate) s3_encryption_enabled: ::std::option::Option<bool>,
     pub(crate) s3_key_prefix: ::std::option::Option<::std::string::String>,
-209
+}
 impl ExecuteCommandLogConfigurationBuilder {
     /// <p>The name of the CloudWatch log group to send logs to.</p><note>
     /// <p>The CloudWatch log group must already be created.</p>
     /// </note>
     pub fn cloud_watch_log_group_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.cloud_watch_log_group_name = ::std::option::Option::Some(input.into());
         self
-217
+    }
     /// <p>The name of the CloudWatch log group to send logs to.</p><note>
     /// <p>The CloudWatch log group must already be created.</p>
     /// </note>
     pub fn set_cloud_watch_log_group_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.cloud_watch_log_group_name = input;

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_f_sx_windows_file_server_authorization_config.rs

@@ -7,7 +139,152 @@

↥ Expand context

 pub struct FSxWindowsFileServerAuthorizationConfig {
     /// <p>The authorization credential option to use. The authorization credential options can be provided using either the Amazon Resource Name (ARN) of an Secrets Manager secret or SSM Parameter Store parameter. The ARN refers to the stored credentials.</p>
     pub credentials_parameter: ::std::string::String,
     /// <p>A fully qualified domain name hosted by an <a href="https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html">Directory Service</a> Managed Microsoft AD (Active Directory) or self-hosted AD on Amazon EC2.</p>
     pub domain: ::std::string::String,
-12
+}
 impl FSxWindowsFileServerAuthorizationConfig {
     /// <p>The authorization credential option to use. The authorization credential options can be provided using either the Amazon Resource Name (ARN) of an Secrets Manager secret or SSM Parameter Store parameter. The ARN refers to the stored credentials.</p>
     pub fn credentials_parameter(&self) -> &str {
         use std::ops::Deref;
         self.credentials_parameter.deref()
-18
+    }
     /// <p>A fully qualified domain name hosted by an <a href="https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html">Directory Service</a> Managed Microsoft AD (Active Directory) or self-hosted AD on Amazon EC2.</p>
     pub fn domain(&self) -> &str {
         use std::ops::Deref;
         self.domain.deref()
-23
+    }
-24
+}
 static FSXWINDOWSFILESERVERAUTHORIZATIONCONFIG_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs#FSxWindowsFileServerAuthorizationConfig",

     "com.amazonaws.ecs",
     "FSxWindowsFileServerAuthorizationConfig",
 );
 static FSXWINDOWSFILESERVERAUTHORIZATIONCONFIG_MEMBER_CREDENTIALS_PARAMETER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#FSxWindowsFileServerAuthorizationConfig$credentialsParameter",
         "com.amazonaws.ecs",
         "FSxWindowsFileServerAuthorizationConfig",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "credentials_parameter",
     "credentialsParameter",
 ,
 );
 static FSXWINDOWSFILESERVERAUTHORIZATIONCONFIG_MEMBER_DOMAIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#FSxWindowsFileServerAuthorizationConfig$domain",
         "com.amazonaws.ecs",
         "FSxWindowsFileServerAuthorizationConfig",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "domain",
 ,
 );
 static FSXWINDOWSFILESERVERAUTHORIZATIONCONFIG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FSXWINDOWSFILESERVERAUTHORIZATIONCONFIG_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &FSXWINDOWSFILESERVERAUTHORIZATIONCONFIG_MEMBER_CREDENTIALS_PARAMETER,
         &FSXWINDOWSFILESERVERAUTHORIZATIONCONFIG_MEMBER_DOMAIN,
     ],
 );
 impl FSxWindowsFileServerAuthorizationConfig {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FSXWINDOWSFILESERVERAUTHORIZATIONCONFIG_SCHEMA;
-61
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FSxWindowsFileServerAuthorizationConfig {
     #[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> {
-68
+        {
             let val = &self.credentials_parameter;
             ser.write_string(&FSXWINDOWSFILESERVERAUTHORIZATIONCONFIG_MEMBER_CREDENTIALS_PARAMETER, val)?;
-71
+        }
-72
+        {
             let val = &self.domain;
             ser.write_string(&FSXWINDOWSFILESERVERAUTHORIZATIONCONFIG_MEMBER_DOMAIN, val)?;
-75
+        }
         Ok(())
-77
+    }
-78
+}
 impl FSxWindowsFileServerAuthorizationConfig {
     /// 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(&FSXWINDOWSFILESERVERAUTHORIZATIONCONFIG_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FSXWINDOWSFILESERVERAUTHORIZATIONCONFIG_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.credentials_parameter = Some(deser.read_string(member)?);
-97
+                }
                 Some(1) => {
                     builder.domain = Some(deser.read_string(member)?);
-100
+                }
                 _ => {}
-102
+            }
             Ok(())
         })?;
         builder.credentials_parameter = builder.credentials_parameter.or(Some(String::new()));
         builder.domain = builder.domain.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-110
+    }
-111
+}
 impl FSxWindowsFileServerAuthorizationConfig {
     /// 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 FSxWindowsFileServerAuthorizationConfig {
     /// Creates a new builder-style object to manufacture [`FSxWindowsFileServerAuthorizationConfig`](crate::types::FSxWindowsFileServerAuthorizationConfig).
     pub fn builder() -> crate::types::builders::FSxWindowsFileServerAuthorizationConfigBuilder {
         crate::types::builders::FSxWindowsFileServerAuthorizationConfigBuilder::default()
-127
+    }
-128
+}
-129
 /// A builder for [`FSxWindowsFileServerAuthorizationConfig`](crate::types::FSxWindowsFileServerAuthorizationConfig).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FSxWindowsFileServerAuthorizationConfigBuilder {
     pub(crate) credentials_parameter: ::std::option::Option<::std::string::String>,
     pub(crate) domain: ::std::option::Option<::std::string::String>,
-136
+}
 impl FSxWindowsFileServerAuthorizationConfigBuilder {
     /// <p>The authorization credential option to use. The authorization credential options can be provided using either the Amazon Resource Name (ARN) of an Secrets Manager secret or SSM Parameter Store parameter. The ARN refers to the stored credentials.</p>
     /// This field is required.
     pub fn credentials_parameter(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.credentials_parameter = ::std::option::Option::Some(input.into());
         self
-143
+    }
     /// <p>The authorization credential option to use. The authorization credential options can be provided using either the Amazon Resource Name (ARN) of an Secrets Manager secret or SSM Parameter Store parameter. The ARN refers to the stored credentials.</p>
     pub fn set_credentials_parameter(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.credentials_parameter = input;
         self
-148
+    }
     /// <p>The authorization credential option to use. The authorization credential options can be provided using either the Amazon Resource Name (ARN) of an Secrets Manager secret or SSM Parameter Store parameter. The ARN refers to the stored credentials.</p>
     pub fn get_credentials_parameter(&self) -> &::std::option::Option<::std::string::String> {
         &self.credentials_parameter
-152
+    }

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_f_sx_windows_file_server_volume_configuration.rs

@@ -13,13 +162,175 @@

↥ Expand context

     pub authorization_config: ::std::option::Option<crate::types::FSxWindowsFileServerAuthorizationConfig>,
-14
+}
 impl FSxWindowsFileServerVolumeConfiguration {
     /// <p>The Amazon FSx for Windows File Server file system ID to use.</p>
     pub fn file_system_id(&self) -> &str {
         use std::ops::Deref;
         self.file_system_id.deref()
-20
+    }
     /// <p>The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.</p>
     pub fn root_directory(&self) -> &str {
         use std::ops::Deref;
         self.root_directory.deref()
-25
+    }
     /// <p>The authorization configuration details for the Amazon FSx for Windows File Server file system.</p>
     pub fn authorization_config(&self) -> ::std::option::Option<&crate::types::FSxWindowsFileServerAuthorizationConfig> {
         self.authorization_config.as_ref()
-29
+    }
-30
+}
 static FSXWINDOWSFILESERVERVOLUMECONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ecs#FSxWindowsFileServerVolumeConfiguration",

     "com.amazonaws.ecs",
     "FSxWindowsFileServerVolumeConfiguration",
 );
 static FSXWINDOWSFILESERVERVOLUMECONFIGURATION_MEMBER_FILE_SYSTEM_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#FSxWindowsFileServerVolumeConfiguration$fileSystemId",
         "com.amazonaws.ecs",
         "FSxWindowsFileServerVolumeConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "file_system_id",
     "fileSystemId",
 ,
 );
 static FSXWINDOWSFILESERVERVOLUMECONFIGURATION_MEMBER_ROOT_DIRECTORY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#FSxWindowsFileServerVolumeConfiguration$rootDirectory",
         "com.amazonaws.ecs",
         "FSxWindowsFileServerVolumeConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "root_directory",
     "rootDirectory",
 ,
 );
 static FSXWINDOWSFILESERVERVOLUMECONFIGURATION_MEMBER_AUTHORIZATION_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ecs#FSxWindowsFileServerVolumeConfiguration$authorizationConfig",
         "com.amazonaws.ecs",
         "FSxWindowsFileServerVolumeConfiguration",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "authorization_config",
     "authorizationConfig",
 ,
 );
 static FSXWINDOWSFILESERVERVOLUMECONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FSXWINDOWSFILESERVERVOLUMECONFIGURATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &FSXWINDOWSFILESERVERVOLUMECONFIGURATION_MEMBER_FILE_SYSTEM_ID,
         &FSXWINDOWSFILESERVERVOLUMECONFIGURATION_MEMBER_ROOT_DIRECTORY,
         &FSXWINDOWSFILESERVERVOLUMECONFIGURATION_MEMBER_AUTHORIZATION_CONFIG,
     ],
 );
 impl FSxWindowsFileServerVolumeConfiguration {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FSXWINDOWSFILESERVERVOLUMECONFIGURATION_SCHEMA;
-78
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FSxWindowsFileServerVolumeConfiguration {
     #[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> {
-85
+        {
             let val = &self.file_system_id;
             ser.write_string(&FSXWINDOWSFILESERVERVOLUMECONFIGURATION_MEMBER_FILE_SYSTEM_ID, val)?;
-88
+        }
-89
+        {
             let val = &self.root_directory;
             ser.write_string(&FSXWINDOWSFILESERVERVOLUMECONFIGURATION_MEMBER_ROOT_DIRECTORY, val)?;
-92
+        }
         if let Some(ref val) = self.authorization_config {
             ser.write_struct(&FSXWINDOWSFILESERVERVOLUMECONFIGURATION_MEMBER_AUTHORIZATION_CONFIG, val)?;
-95
+        }
         Ok(())
-97
+    }
-98
+}
 impl FSxWindowsFileServerVolumeConfiguration {
     /// 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(&FSXWINDOWSFILESERVERVOLUMECONFIGURATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FSXWINDOWSFILESERVERVOLUMECONFIGURATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.file_system_id = Some(deser.read_string(member)?);
-117
+                }
                 Some(1) => {
                     builder.root_directory = Some(deser.read_string(member)?);
-120
+                }
                 Some(2) => {
                     builder.authorization_config = Some(crate::types::FSxWindowsFileServerAuthorizationConfig::deserialize(deser)?);
-123
+                }
                 _ => {}
-125
+            }
             Ok(())
         })?;
         builder.file_system_id = builder.file_system_id.or(Some(String::new()));
         builder.root_directory = builder.root_directory.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-133
+    }
-134
+}
 impl FSxWindowsFileServerVolumeConfiguration {
     /// 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 FSxWindowsFileServerVolumeConfiguration {
     /// Creates a new builder-style object to manufacture [`FSxWindowsFileServerVolumeConfiguration`](crate::types::FSxWindowsFileServerVolumeConfiguration).
     pub fn builder() -> crate::types::builders::FSxWindowsFileServerVolumeConfigurationBuilder {
         crate::types::builders::FSxWindowsFileServerVolumeConfigurationBuilder::default()
-150
+    }
-151
+}
-152
 /// A builder for [`FSxWindowsFileServerVolumeConfiguration`](crate::types::FSxWindowsFileServerVolumeConfiguration).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FSxWindowsFileServerVolumeConfigurationBuilder {
     pub(crate) file_system_id: ::std::option::Option<::std::string::String>,
     pub(crate) root_directory: ::std::option::Option<::std::string::String>,
     pub(crate) authorization_config: ::std::option::Option<crate::types::FSxWindowsFileServerAuthorizationConfig>,
-160
+}
 impl FSxWindowsFileServerVolumeConfigurationBuilder {
     /// <p>The Amazon FSx for Windows File Server file system ID to use.</p>
     /// This field is required.
     pub fn file_system_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.file_system_id = ::std::option::Option::Some(input.into());
         self
-167
+    }
     /// <p>The Amazon FSx for Windows File Server file system ID to use.</p>
     pub fn set_file_system_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.file_system_id = input;
         self
-172
+    }
     /// <p>The Amazon FSx for Windows File Server file system ID to use.</p>
     pub fn get_file_system_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.file_system_id

AWS SDK

Files changed: