AWS SDK

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fleet_launch_template_config_request.rs

@@ -8,8 +154,162 @@

     pub launch_template_specification: ::std::option::Option<crate::types::FleetLaunchTemplateSpecificationRequest>,
     /// <p>Any parameters that you specify override the same parameters in the launch template.</p>
     /// <p>For fleets of type <code>request</code> and <code>maintain</code>, a maximum of 300 items is allowed across all launch templates.</p>
     pub overrides: ::std::option::Option<::std::vec::Vec<crate::types::FleetLaunchTemplateOverridesRequest>>,
-12
+}
 impl FleetLaunchTemplateConfigRequest {
     /// <p>The launch template to use. You must specify either the launch template ID or launch template name in the request.</p>
     pub fn launch_template_specification(&self) -> ::std::option::Option<&crate::types::FleetLaunchTemplateSpecificationRequest> {
         self.launch_template_specification.as_ref()
-17
+    }
     /// <p>Any parameters that you specify override the same parameters in the launch template.</p>
     /// <p>For fleets of type <code>request</code> and <code>maintain</code>, a maximum of 300 items is allowed across all launch templates.</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 `.overrides.is_none()`.
     pub fn overrides(&self) -> &[crate::types::FleetLaunchTemplateOverridesRequest] {
         self.overrides.as_deref().unwrap_or_default()
-24
+    }
-25
+}
 static FLEETLAUNCHTEMPLATECONFIGREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#FleetLaunchTemplateConfigRequest",

     "com.amazonaws.ec2",
     "FleetLaunchTemplateConfigRequest",
 );
 static FLEETLAUNCHTEMPLATECONFIGREQUEST_MEMBER_LAUNCH_TEMPLATE_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateConfigRequest$LaunchTemplateSpecification",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateConfigRequest",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "launch_template_specification",
     "LaunchTemplateSpecification",
 ,
 );
 static FLEETLAUNCHTEMPLATECONFIGREQUEST_MEMBER_OVERRIDES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateConfigRequest$Overrides",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateConfigRequest",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "overrides",
     "Overrides",
 ,
 );
 static FLEETLAUNCHTEMPLATECONFIGREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FLEETLAUNCHTEMPLATECONFIGREQUEST_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &FLEETLAUNCHTEMPLATECONFIGREQUEST_MEMBER_LAUNCH_TEMPLATE_SPECIFICATION,
         &FLEETLAUNCHTEMPLATECONFIGREQUEST_MEMBER_OVERRIDES,
     ],
 );
 impl FleetLaunchTemplateConfigRequest {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLEETLAUNCHTEMPLATECONFIGREQUEST_SCHEMA;
-62
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FleetLaunchTemplateConfigRequest {
     #[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.launch_template_specification {
             ser.write_struct(&FLEETLAUNCHTEMPLATECONFIGREQUEST_MEMBER_LAUNCH_TEMPLATE_SPECIFICATION, val)?;
-71
+        }
         if let Some(ref val) = self.overrides {
             ser.write_list(
                 &FLEETLAUNCHTEMPLATECONFIGREQUEST_MEMBER_OVERRIDES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::FleetLaunchTemplateOverridesRequest::SCHEMA, item)?;
-78
+                    }
                     Ok(())
                 },
             )?;
-82
+        }
         Ok(())
-84
+    }
-85
+}
 impl FleetLaunchTemplateConfigRequest {
     /// 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(&FLEETLAUNCHTEMPLATECONFIGREQUEST_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FLEETLAUNCHTEMPLATECONFIGREQUEST_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.launch_template_specification = Some(crate::types::FleetLaunchTemplateSpecificationRequest::deserialize(deser)?);
-104
+                }
                 Some(1) => {
                     builder.overrides = 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::FleetLaunchTemplateOverridesRequest::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::FleetLaunchTemplateOverridesRequest::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-114
+                }
                 _ => {}
-116
+            }
             Ok(())
         })?;
         Ok(builder.build())
-120
+    }
-121
+}
 impl FleetLaunchTemplateConfigRequest {
     /// 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 FleetLaunchTemplateConfigRequest {
     /// Creates a new builder-style object to manufacture [`FleetLaunchTemplateConfigRequest`](crate::types::FleetLaunchTemplateConfigRequest).
     pub fn builder() -> crate::types::builders::FleetLaunchTemplateConfigRequestBuilder {
         crate::types::builders::FleetLaunchTemplateConfigRequestBuilder::default()
-137
+    }
-138
+}
-139
 /// A builder for [`FleetLaunchTemplateConfigRequest`](crate::types::FleetLaunchTemplateConfigRequest).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FleetLaunchTemplateConfigRequestBuilder {
     pub(crate) launch_template_specification: ::std::option::Option<crate::types::FleetLaunchTemplateSpecificationRequest>,
     pub(crate) overrides: ::std::option::Option<::std::vec::Vec<crate::types::FleetLaunchTemplateOverridesRequest>>,
-146
+}
 impl FleetLaunchTemplateConfigRequestBuilder {
     /// <p>The launch template to use. You must specify either the launch template ID or launch template name in the request.</p>
     pub fn launch_template_specification(mut self, input: crate::types::FleetLaunchTemplateSpecificationRequest) -> Self {
         self.launch_template_specification = ::std::option::Option::Some(input);
         self
-152
+    }
     /// <p>The launch template to use. You must specify either the launch template ID or launch template name in the request.</p>
     pub fn set_launch_template_specification(mut self, input: ::std::option::Option<crate::types::FleetLaunchTemplateSpecificationRequest>) -> Self {
         self.launch_template_specification = input;
         self
-157
+    }
     /// <p>The launch template to use. You must specify either the launch template ID or launch template name in the request.</p>
     pub fn get_launch_template_specification(&self) -> &::std::option::Option<crate::types::FleetLaunchTemplateSpecificationRequest> {
         &self.launch_template_specification
-161
+    }
     /// Appends an item to `overrides`.

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fleet_launch_template_overrides.rs

@@ -140,140 +299,299 @@

↥ Expand context

     /// <li>
     /// <p><code>resolve:ssm:<i>parameter-ARN:label</i> </code></p></li>
     /// </ul>
     /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-launch-template.html#use-an-ssm-parameter-instead-of-an-ami-id">Use a Systems Manager parameter instead of an AMI ID</a> in the <i>Amazon EC2 User Guide</i>.</p><note>
     /// <p>This parameter is only available for fleets of type <code>instant</code>. For fleets of type <code>maintain</code> and <code>request</code>, you must specify the AMI ID in the launch template.</p>
     /// </note>
     pub fn image_id(&self) -> ::std::option::Option<&str> {
         self.image_id.as_deref()
-148
+    }
     /// <p>The block device mappings, which define the EBS volumes and instance store volumes to attach to the instance at launch.</p>
     /// <p>Supported only for fleets of type <code>instant</code>.</p>
     /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html">Block device mappings for volumes on Amazon EC2 instances</a> in the <i>Amazon EC2 User Guide</i>.</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 `.block_device_mappings.is_none()`.
     pub fn block_device_mappings(&self) -> &[crate::types::BlockDeviceMappingResponse] {
         self.block_device_mappings.as_deref().unwrap_or_default()
-156
+    }
-157
+}
 static FLEETLAUNCHTEMPLATEOVERRIDES_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#FleetLaunchTemplateOverrides",

     "com.amazonaws.ec2",
     "FleetLaunchTemplateOverrides",
 );
 static FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverrides$InstanceType",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverrides",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_type",
     "InstanceType",
 ,
-172
+)
 .with_xml_name("instanceType");
 static FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_MAX_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverrides$MaxPrice",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverrides",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "max_price",
     "MaxPrice",
 ,
-183
+)
 .with_xml_name("maxPrice");
 static FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverrides$SubnetId",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverrides",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "subnet_id",
     "SubnetId",
 ,
-194
+)
 .with_xml_name("subnetId");
 static FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverrides$AvailabilityZone",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverrides",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone",
     "AvailabilityZone",
 ,
-205
+)
 .with_xml_name("availabilityZone");
 static FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_WEIGHTED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverrides$WeightedCapacity",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverrides",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "weighted_capacity",
     "WeightedCapacity",
 ,
-216
+)
 .with_xml_name("weightedCapacity");
 static FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_PRIORITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverrides$Priority",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverrides",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "priority",
     "Priority",
 ,
-227
+)
 .with_xml_name("priority");
 static FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_PLACEMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverrides$Placement",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverrides",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "placement",
     "Placement",
 ,
-238
+)
 .with_xml_name("placement");
 static FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_INSTANCE_REQUIREMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverrides$InstanceRequirements",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverrides",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "instance_requirements",
     "InstanceRequirements",
 ,
-249
+)
 .with_xml_name("instanceRequirements");
 static FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverrides$ImageId",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverrides",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "image_id",
     "ImageId",
 ,
-260
+)
 .with_xml_name("imageId");
 static FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_BLOCK_DEVICE_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverrides$BlockDeviceMappings",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverrides",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "block_device_mappings",
     "BlockDeviceMappings",
 ,
-271
+)
 .with_xml_name("blockDeviceMappingSet");
 static FLEETLAUNCHTEMPLATEOVERRIDES_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FLEETLAUNCHTEMPLATEOVERRIDES_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_INSTANCE_TYPE,
         &FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_MAX_PRICE,
         &FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_SUBNET_ID,

↧ Expand context

         &FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_AVAILABILITY_ZONE,
         &FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_WEIGHTED_CAPACITY,
         &FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_PRIORITY,
         &FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_PLACEMENT,
         &FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_INSTANCE_REQUIREMENTS,
         &FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_IMAGE_ID,
         &FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_BLOCK_DEVICE_MAPPINGS,
     ],
 );
 impl FleetLaunchTemplateOverrides {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLEETLAUNCHTEMPLATEOVERRIDES_SCHEMA;
-292
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FleetLaunchTemplateOverrides {
     #[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.instance_type {

@@ -312,312 +432,440 @@

↥ Expand context

             ser.write_double(&FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_WEIGHTED_CAPACITY, *val)?;
-313
+        }
         if let Some(ref val) = self.priority {
             ser.write_double(&FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_PRIORITY, *val)?;
-316
+        }
         if let Some(ref val) = self.placement {
             ser.write_struct(&FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_PLACEMENT, val)?;
-319
+        }
         if let Some(ref val) = self.instance_requirements {
             ser.write_struct(&FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_INSTANCE_REQUIREMENTS, val)?;
-322
+        }
         if let Some(ref val) = self.image_id {
             ser.write_string(&FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_IMAGE_ID, val)?;
-325
+        }
         if let Some(ref val) = self.block_device_mappings {
             ser.write_list(
                 &FLEETLAUNCHTEMPLATEOVERRIDES_MEMBER_BLOCK_DEVICE_MAPPINGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::BlockDeviceMappingResponse::SCHEMA, item)?;

-332
+                    }
                     Ok(())
                 },
             )?;
-336
+        }
         Ok(())
-338
+    }
-339
+}
 impl FleetLaunchTemplateOverrides {
     /// 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(&FLEETLAUNCHTEMPLATEOVERRIDES_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FLEETLAUNCHTEMPLATEOVERRIDES_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.instance_type = Some(crate::types::InstanceType::from(deser.read_string(member)?.as_str()));
-358
+                }
                 Some(1) => {
                     builder.max_price = Some(deser.read_string(member)?);
-361
+                }
                 Some(2) => {
                     builder.subnet_id = Some(deser.read_string(member)?);
-364
+                }
                 Some(3) => {
                     builder.availability_zone = Some(deser.read_string(member)?);
-367
+                }
                 Some(4) => {
                     builder.weighted_capacity = Some(deser.read_double(member)?);
-370
+                }
                 Some(5) => {
                     builder.priority = Some(deser.read_double(member)?);
-373
+                }
                 Some(6) => {
                     builder.placement = Some(crate::types::PlacementResponse::deserialize(deser)?);
-376
+                }
                 Some(7) => {
                     builder.instance_requirements = Some(crate::types::InstanceRequirements::deserialize(deser)?);
-379
+                }
                 Some(8) => {
                     builder.image_id = Some(deser.read_string(member)?);
-382
+                }
                 Some(9) => {
                     builder.block_device_mappings = 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::BlockDeviceMappingResponse::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::BlockDeviceMappingResponse::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-392
+                }
                 _ => {}
-394
+            }
             Ok(())
         })?;
         Ok(builder.build())
-398
+    }
-399
+}
 impl FleetLaunchTemplateOverrides {
     /// 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 FleetLaunchTemplateOverrides {
     /// Creates a new builder-style object to manufacture [`FleetLaunchTemplateOverrides`](crate::types::FleetLaunchTemplateOverrides).
     pub fn builder() -> crate::types::builders::FleetLaunchTemplateOverridesBuilder {
         crate::types::builders::FleetLaunchTemplateOverridesBuilder::default()
-415
+    }
-416
+}
-417
 /// A builder for [`FleetLaunchTemplateOverrides`](crate::types::FleetLaunchTemplateOverrides).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FleetLaunchTemplateOverridesBuilder {
     pub(crate) instance_type: ::std::option::Option<crate::types::InstanceType>,
     pub(crate) max_price: ::std::option::Option<::std::string::String>,
     pub(crate) subnet_id: ::std::option::Option<::std::string::String>,
     pub(crate) availability_zone: ::std::option::Option<::std::string::String>,
     pub(crate) weighted_capacity: ::std::option::Option<f64>,
     pub(crate) priority: ::std::option::Option<f64>,
     pub(crate) placement: ::std::option::Option<crate::types::PlacementResponse>,
     pub(crate) instance_requirements: ::std::option::Option<crate::types::InstanceRequirements>,
     pub(crate) image_id: ::std::option::Option<::std::string::String>,
     pub(crate) block_device_mappings: ::std::option::Option<::std::vec::Vec<crate::types::BlockDeviceMappingResponse>>,
-432
+}
 impl FleetLaunchTemplateOverridesBuilder {
     /// <p>The instance type.</p>
     /// <p><code>mac1.metal</code> is not supported as a launch template override.</p><note>
     /// <p>If you specify <code>InstanceType</code>, you can't specify <code>InstanceRequirements</code>.</p>
     /// </note>
     pub fn instance_type(mut self, input: crate::types::InstanceType) -> Self {
         self.instance_type = ::std::option::Option::Some(input);
         self

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fleet_launch_template_overrides_request.rs

@@ -140,140 +291,291 @@

↥ Expand context

     /// <p><code>resolve:ssm:<i>parameter-name:label</i> </code></p></li>
     /// </ul>
     /// <p>To reference a parameter shared from another Amazon Web Services account:</p>
     /// <ul>
     /// <li>
     /// <p><code>resolve:ssm:<i>parameter-ARN</i> </code></p></li>
     /// <li>
     /// <p><code>resolve:ssm:<i>parameter-ARN:version-number</i> </code></p></li>
     /// <li>
     /// <p><code>resolve:ssm:<i>parameter-ARN:label</i> </code></p></li>
     /// </ul>
     /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-launch-template.html#use-an-ssm-parameter-instead-of-an-ami-id">Use a Systems Manager parameter instead of an AMI ID</a> in the <i>Amazon EC2 User Guide</i>.</p><note>
     /// <p>This parameter is only available for fleets of type <code>instant</code>. For fleets of type <code>maintain</code> and <code>request</code>, you must specify the AMI ID in the launch template.</p>
     /// </note>
     pub fn image_id(&self) -> ::std::option::Option<&str> {
         self.image_id.as_deref()
-156
+    }
-157
+}
 static FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#FleetLaunchTemplateOverridesRequest",

     "com.amazonaws.ec2",
     "FleetLaunchTemplateOverridesRequest",
 );
 static FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverridesRequest$InstanceType",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverridesRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_type",
     "InstanceType",
 ,
 );
 static FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_MAX_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverridesRequest$MaxPrice",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverridesRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "max_price",
     "MaxPrice",
 ,
 );
 static FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverridesRequest$SubnetId",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverridesRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "subnet_id",
     "SubnetId",
 ,
 );
 static FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverridesRequest$AvailabilityZone",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverridesRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone",
     "AvailabilityZone",
 ,
 );
 static FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_WEIGHTED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverridesRequest$WeightedCapacity",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverridesRequest",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "weighted_capacity",
     "WeightedCapacity",
 ,
 );
 static FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_PRIORITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverridesRequest$Priority",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverridesRequest",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "priority",
     "Priority",
 ,
 );
 static FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_PLACEMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverridesRequest$Placement",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverridesRequest",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "placement",
     "Placement",
 ,
 );
 static FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_BLOCK_DEVICE_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverridesRequest$BlockDeviceMappings",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverridesRequest",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "block_device_mappings",
     "BlockDeviceMappings",
 ,
-242
+)
 .with_xml_name("BlockDeviceMapping");
 static FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_INSTANCE_REQUIREMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverridesRequest$InstanceRequirements",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverridesRequest",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "instance_requirements",
     "InstanceRequirements",
 ,
 );
 static FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateOverridesRequest$ImageId",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateOverridesRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "image_id",
     "ImageId",
 ,
 );
 static FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_INSTANCE_TYPE,
         &FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_MAX_PRICE,
         &FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_SUBNET_ID,
         &FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_AVAILABILITY_ZONE,

↧ Expand context

         &FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_WEIGHTED_CAPACITY,
         &FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_PRIORITY,
         &FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_PLACEMENT,
         &FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_BLOCK_DEVICE_MAPPINGS,
         &FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_INSTANCE_REQUIREMENTS,
         &FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_IMAGE_ID,
     ],
 );
 impl FleetLaunchTemplateOverridesRequest {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_SCHEMA;
-283
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FleetLaunchTemplateOverridesRequest {
     #[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.instance_type {
             ser.write_string(&FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_INSTANCE_TYPE, val.as_str())?;

@@ -303,303 +423,431 @@

↥ Expand context

             ser.write_double(&FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_WEIGHTED_CAPACITY, *val)?;
-304
+        }
         if let Some(ref val) = self.priority {
             ser.write_double(&FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_PRIORITY, *val)?;
-307
+        }
         if let Some(ref val) = self.placement {
             ser.write_struct(&FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_PLACEMENT, val)?;
-310
+        }
         if let Some(ref val) = self.block_device_mappings {
             ser.write_list(
                 &FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_BLOCK_DEVICE_MAPPINGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::FleetBlockDeviceMappingRequest::SCHEMA, item)?;
-317
+                    }
                     Ok(())
                 },
             )?;
-321
+        }
         if let Some(ref val) = self.instance_requirements {

             ser.write_struct(&FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_INSTANCE_REQUIREMENTS, val)?;
-324
+        }
         if let Some(ref val) = self.image_id {
             ser.write_string(&FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_MEMBER_IMAGE_ID, val)?;
-327
+        }
         Ok(())
-329
+    }
-330
+}
 impl FleetLaunchTemplateOverridesRequest {
     /// 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(&FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FLEETLAUNCHTEMPLATEOVERRIDESREQUEST_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.instance_type = Some(crate::types::InstanceType::from(deser.read_string(member)?.as_str()));
-349
+                }
                 Some(1) => {
                     builder.max_price = Some(deser.read_string(member)?);
-352
+                }
                 Some(2) => {
                     builder.subnet_id = Some(deser.read_string(member)?);
-355
+                }
                 Some(3) => {
                     builder.availability_zone = Some(deser.read_string(member)?);
-358
+                }
                 Some(4) => {
                     builder.weighted_capacity = Some(deser.read_double(member)?);
-361
+                }
                 Some(5) => {
                     builder.priority = Some(deser.read_double(member)?);
-364
+                }
                 Some(6) => {
                     builder.placement = Some(crate::types::Placement::deserialize(deser)?);
-367
+                }
                 Some(7) => {
                     builder.block_device_mappings = 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::FleetBlockDeviceMappingRequest::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::FleetBlockDeviceMappingRequest::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-377
+                }
                 Some(8) => {
                     builder.instance_requirements = Some(crate::types::InstanceRequirementsRequest::deserialize(deser)?);
-380
+                }
                 Some(9) => {
                     builder.image_id = Some(deser.read_string(member)?);
-383
+                }
                 _ => {}
-385
+            }
             Ok(())
         })?;
         Ok(builder.build())
-389
+    }
-390
+}
 impl FleetLaunchTemplateOverridesRequest {
     /// 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 FleetLaunchTemplateOverridesRequest {
     /// Creates a new builder-style object to manufacture [`FleetLaunchTemplateOverridesRequest`](crate::types::FleetLaunchTemplateOverridesRequest).
     pub fn builder() -> crate::types::builders::FleetLaunchTemplateOverridesRequestBuilder {
         crate::types::builders::FleetLaunchTemplateOverridesRequestBuilder::default()
-406
+    }
-407
+}
-408
 /// A builder for [`FleetLaunchTemplateOverridesRequest`](crate::types::FleetLaunchTemplateOverridesRequest).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FleetLaunchTemplateOverridesRequestBuilder {
     pub(crate) instance_type: ::std::option::Option<crate::types::InstanceType>,
     pub(crate) max_price: ::std::option::Option<::std::string::String>,
     pub(crate) subnet_id: ::std::option::Option<::std::string::String>,
     pub(crate) availability_zone: ::std::option::Option<::std::string::String>,
     pub(crate) weighted_capacity: ::std::option::Option<f64>,
     pub(crate) priority: ::std::option::Option<f64>,
     pub(crate) placement: ::std::option::Option<crate::types::Placement>,
     pub(crate) block_device_mappings: ::std::option::Option<::std::vec::Vec<crate::types::FleetBlockDeviceMappingRequest>>,
     pub(crate) instance_requirements: ::std::option::Option<crate::types::InstanceRequirementsRequest>,
     pub(crate) image_id: ::std::option::Option<::std::string::String>,
-423
+}
 impl FleetLaunchTemplateOverridesRequestBuilder {
     /// <p>The instance type.</p>
     /// <p><code>mac1.metal</code> is not supported as a launch template override.</p><note>
     /// <p>If you specify <code>InstanceType</code>, you can't specify <code>InstanceRequirements</code>.</p>
     /// </note>
     pub fn instance_type(mut self, input: crate::types::InstanceType) -> Self {
         self.instance_type = ::std::option::Option::Some(input);
         self

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fleet_launch_template_specification.rs

@@ -19,19 +167,178 @@

↥ Expand context

 impl FleetLaunchTemplateSpecification {
     /// <p>The ID of the launch template.</p>
     /// <p>You must specify the <code>LaunchTemplateId</code> or the <code>LaunchTemplateName</code>, but not both.</p>
     pub fn launch_template_id(&self) -> ::std::option::Option<&str> {
         self.launch_template_id.as_deref()
-24
+    }
     /// <p>The name of the launch template.</p>
     /// <p>You must specify the <code>LaunchTemplateName</code> or the <code>LaunchTemplateId</code>, but not both.</p>
     pub fn launch_template_name(&self) -> ::std::option::Option<&str> {
         self.launch_template_name.as_deref()
-29
+    }
     /// <p>The launch template version number, <code>$Latest</code>, or <code>$Default</code>. You must specify a value, otherwise the request fails.</p>
     /// <p>If the value is <code>$Latest</code>, Amazon EC2 uses the latest version of the launch template.</p>
     /// <p>If the value is <code>$Default</code>, Amazon EC2 uses the default version of the launch template.</p>
     pub fn version(&self) -> ::std::option::Option<&str> {
         self.version.as_deref()
-35
+    }
-36
+}
 static FLEETLAUNCHTEMPLATESPECIFICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#FleetLaunchTemplateSpecification",

     "com.amazonaws.ec2",
     "FleetLaunchTemplateSpecification",
 );
 static FLEETLAUNCHTEMPLATESPECIFICATION_MEMBER_LAUNCH_TEMPLATE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateSpecification$LaunchTemplateId",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "launch_template_id",
     "LaunchTemplateId",
 ,
-51
+)
 .with_xml_name("launchTemplateId");
 static FLEETLAUNCHTEMPLATESPECIFICATION_MEMBER_LAUNCH_TEMPLATE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateSpecification$LaunchTemplateName",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "launch_template_name",
     "LaunchTemplateName",
 ,
-62
+)
 .with_xml_name("launchTemplateName");
 static FLEETLAUNCHTEMPLATESPECIFICATION_MEMBER_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateSpecification$Version",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "version",
     "Version",
 ,
-73
+)
 .with_xml_name("version");
 static FLEETLAUNCHTEMPLATESPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FLEETLAUNCHTEMPLATESPECIFICATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &FLEETLAUNCHTEMPLATESPECIFICATION_MEMBER_LAUNCH_TEMPLATE_ID,
         &FLEETLAUNCHTEMPLATESPECIFICATION_MEMBER_LAUNCH_TEMPLATE_NAME,
         &FLEETLAUNCHTEMPLATESPECIFICATION_MEMBER_VERSION,
     ],
 );
 impl FleetLaunchTemplateSpecification {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLEETLAUNCHTEMPLATESPECIFICATION_SCHEMA;
-87
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FleetLaunchTemplateSpecification {
     #[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.launch_template_id {
             ser.write_string(&FLEETLAUNCHTEMPLATESPECIFICATION_MEMBER_LAUNCH_TEMPLATE_ID, val)?;
-96
+        }
         if let Some(ref val) = self.launch_template_name {
             ser.write_string(&FLEETLAUNCHTEMPLATESPECIFICATION_MEMBER_LAUNCH_TEMPLATE_NAME, val)?;
-99
+        }
         if let Some(ref val) = self.version {
             ser.write_string(&FLEETLAUNCHTEMPLATESPECIFICATION_MEMBER_VERSION, val)?;
-102
+        }
         Ok(())
-104
+    }
-105
+}
 impl FleetLaunchTemplateSpecification {
     /// 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(&FLEETLAUNCHTEMPLATESPECIFICATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FLEETLAUNCHTEMPLATESPECIFICATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.launch_template_id = Some(deser.read_string(member)?);
-124
+                }
                 Some(1) => {
                     builder.launch_template_name = Some(deser.read_string(member)?);
-127
+                }
                 Some(2) => {
                     builder.version = Some(deser.read_string(member)?);
-130
+                }
                 _ => {}
-132
+            }
             Ok(())
         })?;
         Ok(builder.build())
-136
+    }
-137
+}
 impl FleetLaunchTemplateSpecification {
     /// 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 FleetLaunchTemplateSpecification {
     /// Creates a new builder-style object to manufacture [`FleetLaunchTemplateSpecification`](crate::types::FleetLaunchTemplateSpecification).
     pub fn builder() -> crate::types::builders::FleetLaunchTemplateSpecificationBuilder {
         crate::types::builders::FleetLaunchTemplateSpecificationBuilder::default()
-153
+    }
-154
+}
-155
 /// A builder for [`FleetLaunchTemplateSpecification`](crate::types::FleetLaunchTemplateSpecification).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FleetLaunchTemplateSpecificationBuilder {
     pub(crate) launch_template_id: ::std::option::Option<::std::string::String>,
     pub(crate) launch_template_name: ::std::option::Option<::std::string::String>,
     pub(crate) version: ::std::option::Option<::std::string::String>,
-163
+}
 impl FleetLaunchTemplateSpecificationBuilder {
     /// <p>The ID of the launch template.</p>
     /// <p>You must specify the <code>LaunchTemplateId</code> or the <code>LaunchTemplateName</code>, but not both.</p>
     pub fn launch_template_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.launch_template_id = ::std::option::Option::Some(input.into());
         self
-170
+    }
     /// <p>The ID of the launch template.</p>
     /// <p>You must specify the <code>LaunchTemplateId</code> or the <code>LaunchTemplateName</code>, but not both.</p>
     pub fn set_launch_template_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.launch_template_id = input;
         self
-176
+    }
     /// <p>The ID of the launch template.</p>
     /// <p>You must specify the <code>LaunchTemplateId</code> or the <code>LaunchTemplateName</code>, but not both.</p>

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fleet_launch_template_specification_request.rs

@@ -19,19 +164,175 @@

↥ Expand context

 impl FleetLaunchTemplateSpecificationRequest {
     /// <p>The ID of the launch template.</p>
     /// <p>You must specify the <code>LaunchTemplateId</code> or the <code>LaunchTemplateName</code>, but not both.</p>
     pub fn launch_template_id(&self) -> ::std::option::Option<&str> {
         self.launch_template_id.as_deref()
-24
+    }
     /// <p>The name of the launch template.</p>
     /// <p>You must specify the <code>LaunchTemplateName</code> or the <code>LaunchTemplateId</code>, but not both.</p>
     pub fn launch_template_name(&self) -> ::std::option::Option<&str> {
         self.launch_template_name.as_deref()
-29
+    }
     /// <p>The launch template version number, <code>$Latest</code>, or <code>$Default</code>. You must specify a value, otherwise the request fails.</p>
     /// <p>If the value is <code>$Latest</code>, Amazon EC2 uses the latest version of the launch template.</p>
     /// <p>If the value is <code>$Default</code>, Amazon EC2 uses the default version of the launch template.</p>
     pub fn version(&self) -> ::std::option::Option<&str> {
         self.version.as_deref()
-35
+    }
-36
+}
 static FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#FleetLaunchTemplateSpecificationRequest",

     "com.amazonaws.ec2",
     "FleetLaunchTemplateSpecificationRequest",
 );
 static FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_MEMBER_LAUNCH_TEMPLATE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateSpecificationRequest$LaunchTemplateId",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateSpecificationRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "launch_template_id",
     "LaunchTemplateId",
 ,
 );
 static FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_MEMBER_LAUNCH_TEMPLATE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateSpecificationRequest$LaunchTemplateName",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateSpecificationRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "launch_template_name",
     "LaunchTemplateName",
 ,
 );
 static FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_MEMBER_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetLaunchTemplateSpecificationRequest$Version",
         "com.amazonaws.ec2",
         "FleetLaunchTemplateSpecificationRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "version",
     "Version",
 ,
 );
 static FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_MEMBER_LAUNCH_TEMPLATE_ID,
         &FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_MEMBER_LAUNCH_TEMPLATE_NAME,
         &FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_MEMBER_VERSION,
     ],
 );
 impl FleetLaunchTemplateSpecificationRequest {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_SCHEMA;
-84
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FleetLaunchTemplateSpecificationRequest {
     #[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.launch_template_id {
             ser.write_string(&FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_MEMBER_LAUNCH_TEMPLATE_ID, val)?;
-93
+        }
         if let Some(ref val) = self.launch_template_name {
             ser.write_string(&FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_MEMBER_LAUNCH_TEMPLATE_NAME, val)?;
-96
+        }
         if let Some(ref val) = self.version {
             ser.write_string(&FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_MEMBER_VERSION, val)?;
-99
+        }
         Ok(())
-101
+    }
-102
+}
 impl FleetLaunchTemplateSpecificationRequest {
     /// 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(&FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FLEETLAUNCHTEMPLATESPECIFICATIONREQUEST_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.launch_template_id = Some(deser.read_string(member)?);
-121
+                }
                 Some(1) => {
                     builder.launch_template_name = Some(deser.read_string(member)?);
-124
+                }
                 Some(2) => {
                     builder.version = Some(deser.read_string(member)?);
-127
+                }
                 _ => {}
-129
+            }
             Ok(())
         })?;
         Ok(builder.build())
-133
+    }
-134
+}
 impl FleetLaunchTemplateSpecificationRequest {
     /// 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 FleetLaunchTemplateSpecificationRequest {
     /// Creates a new builder-style object to manufacture [`FleetLaunchTemplateSpecificationRequest`](crate::types::FleetLaunchTemplateSpecificationRequest).
     pub fn builder() -> crate::types::builders::FleetLaunchTemplateSpecificationRequestBuilder {
         crate::types::builders::FleetLaunchTemplateSpecificationRequestBuilder::default()
-150
+    }
-151
+}
-152
 /// A builder for [`FleetLaunchTemplateSpecificationRequest`](crate::types::FleetLaunchTemplateSpecificationRequest).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FleetLaunchTemplateSpecificationRequestBuilder {
     pub(crate) launch_template_id: ::std::option::Option<::std::string::String>,
     pub(crate) launch_template_name: ::std::option::Option<::std::string::String>,
     pub(crate) version: ::std::option::Option<::std::string::String>,
-160
+}
 impl FleetLaunchTemplateSpecificationRequestBuilder {
     /// <p>The ID of the launch template.</p>
     /// <p>You must specify the <code>LaunchTemplateId</code> or the <code>LaunchTemplateName</code>, but not both.</p>
     pub fn launch_template_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.launch_template_id = ::std::option::Option::Some(input.into());
         self
-167
+    }
     /// <p>The ID of the launch template.</p>
     /// <p>You must specify the <code>LaunchTemplateId</code> or the <code>LaunchTemplateName</code>, but not both.</p>
     pub fn set_launch_template_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.launch_template_id = input;
         self
-173
+    }
     /// <p>The ID of the launch template.</p>
     /// <p>You must specify the <code>LaunchTemplateId</code> or the <code>LaunchTemplateName</code>, but not both.</p>

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fleet_spot_capacity_rebalance.rs

@@ -14,14 +144,155 @@

↥ Expand context

     /// <p>Valid values: Minimum value of <code>120</code> seconds. Maximum value of <code>7200</code> seconds.</p>
     pub termination_delay: ::std::option::Option<i32>,
-16
+}
 impl FleetSpotCapacityRebalance {
     /// <p>The replacement strategy to use. Only available for fleets of type <code>maintain</code>.</p>
     /// <p><code>launch</code> - EC2 Fleet launches a new replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet. EC2 Fleet does not terminate the instances that receive a rebalance notification. You can terminate the old instances, or you can leave them running. You are charged for all instances while they are running.</p>
     /// <p><code>launch-before-terminate</code> - EC2 Fleet launches a new replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet, and then, after a delay that you specify (in <code>TerminationDelay</code>), terminates the instances that received a rebalance notification.</p>
     pub fn replacement_strategy(&self) -> ::std::option::Option<&crate::types::FleetReplacementStrategy> {
         self.replacement_strategy.as_ref()
-23
+    }
     /// <p>The amount of time (in seconds) that Amazon EC2 waits before terminating the old Spot Instance after launching a new replacement Spot Instance.</p>
     /// <p>Required when <code>ReplacementStrategy</code> is set to <code>launch-before-terminate</code>.</p>
     /// <p>Not valid when <code>ReplacementStrategy</code> is set to <code>launch</code>.</p>
     /// <p>Valid values: Minimum value of <code>120</code> seconds. Maximum value of <code>7200</code> seconds.</p>
     pub fn termination_delay(&self) -> ::std::option::Option<i32> {
         self.termination_delay
-30
+    }
-31
+}
 static FLEETSPOTCAPACITYREBALANCE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#FleetSpotCapacityRebalance",

     "com.amazonaws.ec2",
     "FleetSpotCapacityRebalance",
 );
 static FLEETSPOTCAPACITYREBALANCE_MEMBER_REPLACEMENT_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetSpotCapacityRebalance$ReplacementStrategy",
         "com.amazonaws.ec2",
         "FleetSpotCapacityRebalance",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "replacement_strategy",
     "ReplacementStrategy",
 ,
-46
+)
 .with_xml_name("replacementStrategy");
 static FLEETSPOTCAPACITYREBALANCE_MEMBER_TERMINATION_DELAY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetSpotCapacityRebalance$TerminationDelay",
         "com.amazonaws.ec2",
         "FleetSpotCapacityRebalance",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "termination_delay",
     "TerminationDelay",
 ,
-57
+)
 .with_xml_name("terminationDelay");
 static FLEETSPOTCAPACITYREBALANCE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FLEETSPOTCAPACITYREBALANCE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &FLEETSPOTCAPACITYREBALANCE_MEMBER_REPLACEMENT_STRATEGY,
         &FLEETSPOTCAPACITYREBALANCE_MEMBER_TERMINATION_DELAY,
     ],
 );
 impl FleetSpotCapacityRebalance {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLEETSPOTCAPACITYREBALANCE_SCHEMA;
-70
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FleetSpotCapacityRebalance {
     #[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.replacement_strategy {
             ser.write_string(&FLEETSPOTCAPACITYREBALANCE_MEMBER_REPLACEMENT_STRATEGY, val.as_str())?;
-79
+        }
         if let Some(ref val) = self.termination_delay {
             ser.write_integer(&FLEETSPOTCAPACITYREBALANCE_MEMBER_TERMINATION_DELAY, *val)?;
-82
+        }
         Ok(())
-84
+    }
-85
+}
 impl FleetSpotCapacityRebalance {
     /// 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(&FLEETSPOTCAPACITYREBALANCE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FLEETSPOTCAPACITYREBALANCE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.replacement_strategy = Some(crate::types::FleetReplacementStrategy::from(deser.read_string(member)?.as_str()));
-104
+                }
                 Some(1) => {
                     builder.termination_delay = Some(deser.read_integer(member)?);
-107
+                }
                 _ => {}
-109
+            }
             Ok(())
         })?;
         Ok(builder.build())
-113
+    }
-114
+}
 impl FleetSpotCapacityRebalance {
     /// 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 FleetSpotCapacityRebalance {
     /// Creates a new builder-style object to manufacture [`FleetSpotCapacityRebalance`](crate::types::FleetSpotCapacityRebalance).
     pub fn builder() -> crate::types::builders::FleetSpotCapacityRebalanceBuilder {
         crate::types::builders::FleetSpotCapacityRebalanceBuilder::default()
-130
+    }
-131
+}
-132
 /// A builder for [`FleetSpotCapacityRebalance`](crate::types::FleetSpotCapacityRebalance).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FleetSpotCapacityRebalanceBuilder {
     pub(crate) replacement_strategy: ::std::option::Option<crate::types::FleetReplacementStrategy>,
     pub(crate) termination_delay: ::std::option::Option<i32>,
-139
+}
 impl FleetSpotCapacityRebalanceBuilder {
     /// <p>The replacement strategy to use. Only available for fleets of type <code>maintain</code>.</p>
     /// <p><code>launch</code> - EC2 Fleet launches a new replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet. EC2 Fleet does not terminate the instances that receive a rebalance notification. You can terminate the old instances, or you can leave them running. You are charged for all instances while they are running.</p>
     /// <p><code>launch-before-terminate</code> - EC2 Fleet launches a new replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet, and then, after a delay that you specify (in <code>TerminationDelay</code>), terminates the instances that received a rebalance notification.</p>
     pub fn replacement_strategy(mut self, input: crate::types::FleetReplacementStrategy) -> Self {
         self.replacement_strategy = ::std::option::Option::Some(input);
         self
-147
+    }
     /// <p>The replacement strategy to use. Only available for fleets of type <code>maintain</code>.</p>
     /// <p><code>launch</code> - EC2 Fleet launches a new replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet. EC2 Fleet does not terminate the instances that receive a rebalance notification. You can terminate the old instances, or you can leave them running. You are charged for all instances while they are running.</p>
     /// <p><code>launch-before-terminate</code> - EC2 Fleet launches a new replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet, and then, after a delay that you specify (in <code>TerminationDelay</code>), terminates the instances that received a rebalance notification.</p>
     pub fn set_replacement_strategy(mut self, input: ::std::option::Option<crate::types::FleetReplacementStrategy>) -> Self {
         self.replacement_strategy = input;
         self
-154
+    }
     /// <p>The replacement strategy to use. Only available for fleets of type <code>maintain</code>.</p>

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fleet_spot_capacity_rebalance_request.rs

@@ -14,14 +142,153 @@

↥ Expand context

     /// <p>Valid values: Minimum value of <code>120</code> seconds. Maximum value of <code>7200</code> seconds.</p>
     pub termination_delay: ::std::option::Option<i32>,
-16
+}
 impl FleetSpotCapacityRebalanceRequest {
     /// <p>The replacement strategy to use. Only available for fleets of type <code>maintain</code>.</p>
     /// <p><code>launch</code> - EC2 Fleet launches a replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet. EC2 Fleet does not terminate the instances that receive a rebalance notification. You can terminate the old instances, or you can leave them running. You are charged for all instances while they are running.</p>
     /// <p><code>launch-before-terminate</code> - EC2 Fleet launches a replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet, and then, after a delay that you specify (in <code>TerminationDelay</code>), terminates the instances that received a rebalance notification.</p>
     pub fn replacement_strategy(&self) -> ::std::option::Option<&crate::types::FleetReplacementStrategy> {
         self.replacement_strategy.as_ref()
-23
+    }
     /// <p>The amount of time (in seconds) that Amazon EC2 waits before terminating the old Spot Instance after launching a new replacement Spot Instance.</p>
     /// <p>Required when <code>ReplacementStrategy</code> is set to <code>launch-before-terminate</code>.</p>
     /// <p>Not valid when <code>ReplacementStrategy</code> is set to <code>launch</code>.</p>
     /// <p>Valid values: Minimum value of <code>120</code> seconds. Maximum value of <code>7200</code> seconds.</p>
     pub fn termination_delay(&self) -> ::std::option::Option<i32> {
         self.termination_delay
-30
+    }
-31
+}
 static FLEETSPOTCAPACITYREBALANCEREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#FleetSpotCapacityRebalanceRequest",

     "com.amazonaws.ec2",
     "FleetSpotCapacityRebalanceRequest",
 );
 static FLEETSPOTCAPACITYREBALANCEREQUEST_MEMBER_REPLACEMENT_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetSpotCapacityRebalanceRequest$ReplacementStrategy",
         "com.amazonaws.ec2",
         "FleetSpotCapacityRebalanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "replacement_strategy",
     "ReplacementStrategy",
 ,
 );
 static FLEETSPOTCAPACITYREBALANCEREQUEST_MEMBER_TERMINATION_DELAY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetSpotCapacityRebalanceRequest$TerminationDelay",
         "com.amazonaws.ec2",
         "FleetSpotCapacityRebalanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "termination_delay",
     "TerminationDelay",
 ,
 );
 static FLEETSPOTCAPACITYREBALANCEREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FLEETSPOTCAPACITYREBALANCEREQUEST_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &FLEETSPOTCAPACITYREBALANCEREQUEST_MEMBER_REPLACEMENT_STRATEGY,
         &FLEETSPOTCAPACITYREBALANCEREQUEST_MEMBER_TERMINATION_DELAY,
     ],
 );
 impl FleetSpotCapacityRebalanceRequest {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLEETSPOTCAPACITYREBALANCEREQUEST_SCHEMA;
-68
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FleetSpotCapacityRebalanceRequest {
     #[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.replacement_strategy {
             ser.write_string(&FLEETSPOTCAPACITYREBALANCEREQUEST_MEMBER_REPLACEMENT_STRATEGY, val.as_str())?;
-77
+        }
         if let Some(ref val) = self.termination_delay {
             ser.write_integer(&FLEETSPOTCAPACITYREBALANCEREQUEST_MEMBER_TERMINATION_DELAY, *val)?;
-80
+        }
         Ok(())
-82
+    }
-83
+}
 impl FleetSpotCapacityRebalanceRequest {
     /// 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(&FLEETSPOTCAPACITYREBALANCEREQUEST_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FLEETSPOTCAPACITYREBALANCEREQUEST_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.replacement_strategy = Some(crate::types::FleetReplacementStrategy::from(deser.read_string(member)?.as_str()));
-102
+                }
                 Some(1) => {
                     builder.termination_delay = Some(deser.read_integer(member)?);
-105
+                }
                 _ => {}
-107
+            }
             Ok(())
         })?;
         Ok(builder.build())
-111
+    }
-112
+}
 impl FleetSpotCapacityRebalanceRequest {
     /// 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 FleetSpotCapacityRebalanceRequest {
     /// Creates a new builder-style object to manufacture [`FleetSpotCapacityRebalanceRequest`](crate::types::FleetSpotCapacityRebalanceRequest).
     pub fn builder() -> crate::types::builders::FleetSpotCapacityRebalanceRequestBuilder {
         crate::types::builders::FleetSpotCapacityRebalanceRequestBuilder::default()
-128
+    }
-129
+}
-130
 /// A builder for [`FleetSpotCapacityRebalanceRequest`](crate::types::FleetSpotCapacityRebalanceRequest).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FleetSpotCapacityRebalanceRequestBuilder {
     pub(crate) replacement_strategy: ::std::option::Option<crate::types::FleetReplacementStrategy>,
     pub(crate) termination_delay: ::std::option::Option<i32>,
-137
+}
 impl FleetSpotCapacityRebalanceRequestBuilder {
     /// <p>The replacement strategy to use. Only available for fleets of type <code>maintain</code>.</p>
     /// <p><code>launch</code> - EC2 Fleet launches a replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet. EC2 Fleet does not terminate the instances that receive a rebalance notification. You can terminate the old instances, or you can leave them running. You are charged for all instances while they are running.</p>
     /// <p><code>launch-before-terminate</code> - EC2 Fleet launches a replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet, and then, after a delay that you specify (in <code>TerminationDelay</code>), terminates the instances that received a rebalance notification.</p>
     pub fn replacement_strategy(mut self, input: crate::types::FleetReplacementStrategy) -> Self {
         self.replacement_strategy = ::std::option::Option::Some(input);
         self
-145
+    }
     /// <p>The replacement strategy to use. Only available for fleets of type <code>maintain</code>.</p>
     /// <p><code>launch</code> - EC2 Fleet launches a replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet. EC2 Fleet does not terminate the instances that receive a rebalance notification. You can terminate the old instances, or you can leave them running. You are charged for all instances while they are running.</p>
     /// <p><code>launch-before-terminate</code> - EC2 Fleet launches a replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet, and then, after a delay that you specify (in <code>TerminationDelay</code>), terminates the instances that received a rebalance notification.</p>
     pub fn set_replacement_strategy(mut self, input: ::std::option::Option<crate::types::FleetReplacementStrategy>) -> Self {
         self.replacement_strategy = input;
         self
-152
+    }
     /// <p>The replacement strategy to use. Only available for fleets of type <code>maintain</code>.</p>

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fleet_spot_maintenance_strategies.rs

@@ -1,1 +108,119 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The strategies for managing your Spot Instances that are at an elevated risk of being interrupted.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct FleetSpotMaintenanceStrategies {
     /// <p>The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.</p>
     pub capacity_rebalance: ::std::option::Option<crate::types::FleetSpotCapacityRebalance>,
-9
+}
 impl FleetSpotMaintenanceStrategies {
     /// <p>The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.</p>
     pub fn capacity_rebalance(&self) -> ::std::option::Option<&crate::types::FleetSpotCapacityRebalance> {
         self.capacity_rebalance.as_ref()
-14
+    }
-15
+}
 static FLEETSPOTMAINTENANCESTRATEGIES_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#FleetSpotMaintenanceStrategies",

     "com.amazonaws.ec2",
     "FleetSpotMaintenanceStrategies",
 );
 static FLEETSPOTMAINTENANCESTRATEGIES_MEMBER_CAPACITY_REBALANCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetSpotMaintenanceStrategies$CapacityRebalance",
         "com.amazonaws.ec2",
         "FleetSpotMaintenanceStrategies",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "capacity_rebalance",
     "CapacityRebalance",
 ,
-30
+)
 .with_xml_name("capacityRebalance");
 static FLEETSPOTMAINTENANCESTRATEGIES_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FLEETSPOTMAINTENANCESTRATEGIES_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&FLEETSPOTMAINTENANCESTRATEGIES_MEMBER_CAPACITY_REBALANCE],
 );
 impl FleetSpotMaintenanceStrategies {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLEETSPOTMAINTENANCESTRATEGIES_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FleetSpotMaintenanceStrategies {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.capacity_rebalance {
             ser.write_struct(&FLEETSPOTMAINTENANCESTRATEGIES_MEMBER_CAPACITY_REBALANCE, val)?;
-49
+        }
         Ok(())
-51
+    }
-52
+}
 impl FleetSpotMaintenanceStrategies {
     /// 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(&FLEETSPOTMAINTENANCESTRATEGIES_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FLEETSPOTMAINTENANCESTRATEGIES_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.capacity_rebalance = Some(crate::types::FleetSpotCapacityRebalance::deserialize(deser)?);
-71
+                }
                 _ => {}
-73
+            }
             Ok(())
         })?;
         Ok(builder.build())
-77
+    }
-78
+}
 impl FleetSpotMaintenanceStrategies {
     /// 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 FleetSpotMaintenanceStrategies {
     /// Creates a new builder-style object to manufacture [`FleetSpotMaintenanceStrategies`](crate::types::FleetSpotMaintenanceStrategies).
     pub fn builder() -> crate::types::builders::FleetSpotMaintenanceStrategiesBuilder {
         crate::types::builders::FleetSpotMaintenanceStrategiesBuilder::default()
-94
+    }
-95
+}
-96
 /// A builder for [`FleetSpotMaintenanceStrategies`](crate::types::FleetSpotMaintenanceStrategies).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FleetSpotMaintenanceStrategiesBuilder {
     pub(crate) capacity_rebalance: ::std::option::Option<crate::types::FleetSpotCapacityRebalance>,
-102
+}
 impl FleetSpotMaintenanceStrategiesBuilder {
     /// <p>The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.</p>
     pub fn capacity_rebalance(mut self, input: crate::types::FleetSpotCapacityRebalance) -> Self {
         self.capacity_rebalance = ::std::option::Option::Some(input);
         self
-108
+    }
     /// <p>The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.</p>
     pub fn set_capacity_rebalance(mut self, input: ::std::option::Option<crate::types::FleetSpotCapacityRebalance>) -> Self {
         self.capacity_rebalance = input;
         self
-113
+    }
     /// <p>The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.</p>
     pub fn get_capacity_rebalance(&self) -> &::std::option::Option<crate::types::FleetSpotCapacityRebalance> {
         &self.capacity_rebalance
-117
+    }
     /// Consumes the builder and constructs a [`FleetSpotMaintenanceStrategies`](crate::types::FleetSpotMaintenanceStrategies).
     pub fn build(self) -> crate::types::FleetSpotMaintenanceStrategies {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fleet_spot_maintenance_strategies_request.rs

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The strategies for managing your Spot Instances that are at an elevated risk of being interrupted.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct FleetSpotMaintenanceStrategiesRequest {
     /// <p>The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.</p>
     pub capacity_rebalance: ::std::option::Option<crate::types::FleetSpotCapacityRebalanceRequest>,
-9
+}
 impl FleetSpotMaintenanceStrategiesRequest {
     /// <p>The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.</p>
     pub fn capacity_rebalance(&self) -> ::std::option::Option<&crate::types::FleetSpotCapacityRebalanceRequest> {
         self.capacity_rebalance.as_ref()
-14
+    }
-15
+}
 static FLEETSPOTMAINTENANCESTRATEGIESREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#FleetSpotMaintenanceStrategiesRequest",

     "com.amazonaws.ec2",
     "FleetSpotMaintenanceStrategiesRequest",
 );
 static FLEETSPOTMAINTENANCESTRATEGIESREQUEST_MEMBER_CAPACITY_REBALANCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FleetSpotMaintenanceStrategiesRequest$CapacityRebalance",
         "com.amazonaws.ec2",
         "FleetSpotMaintenanceStrategiesRequest",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "capacity_rebalance",
     "CapacityRebalance",
 ,
 );
 static FLEETSPOTMAINTENANCESTRATEGIESREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FLEETSPOTMAINTENANCESTRATEGIESREQUEST_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&FLEETSPOTMAINTENANCESTRATEGIESREQUEST_MEMBER_CAPACITY_REBALANCE],
 );
 impl FleetSpotMaintenanceStrategiesRequest {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLEETSPOTMAINTENANCESTRATEGIESREQUEST_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FleetSpotMaintenanceStrategiesRequest {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.capacity_rebalance {
             ser.write_struct(&FLEETSPOTMAINTENANCESTRATEGIESREQUEST_MEMBER_CAPACITY_REBALANCE, val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl FleetSpotMaintenanceStrategiesRequest {
     /// 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(&FLEETSPOTMAINTENANCESTRATEGIESREQUEST_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FLEETSPOTMAINTENANCESTRATEGIESREQUEST_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.capacity_rebalance = Some(crate::types::FleetSpotCapacityRebalanceRequest::deserialize(deser)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl FleetSpotMaintenanceStrategiesRequest {
     /// 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 FleetSpotMaintenanceStrategiesRequest {
     /// Creates a new builder-style object to manufacture [`FleetSpotMaintenanceStrategiesRequest`](crate::types::FleetSpotMaintenanceStrategiesRequest).
     pub fn builder() -> crate::types::builders::FleetSpotMaintenanceStrategiesRequestBuilder {
         crate::types::builders::FleetSpotMaintenanceStrategiesRequestBuilder::default()
-93
+    }
-94
+}
-95
 /// A builder for [`FleetSpotMaintenanceStrategiesRequest`](crate::types::FleetSpotMaintenanceStrategiesRequest).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FleetSpotMaintenanceStrategiesRequestBuilder {
     pub(crate) capacity_rebalance: ::std::option::Option<crate::types::FleetSpotCapacityRebalanceRequest>,
-101
+}
 impl FleetSpotMaintenanceStrategiesRequestBuilder {
     /// <p>The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.</p>
     pub fn capacity_rebalance(mut self, input: crate::types::FleetSpotCapacityRebalanceRequest) -> Self {
         self.capacity_rebalance = ::std::option::Option::Some(input);
         self
-107
+    }
     /// <p>The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.</p>
     pub fn set_capacity_rebalance(mut self, input: ::std::option::Option<crate::types::FleetSpotCapacityRebalanceRequest>) -> Self {
         self.capacity_rebalance = input;
         self
-112
+    }
     /// <p>The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.</p>
     pub fn get_capacity_rebalance(&self) -> &::std::option::Option<crate::types::FleetSpotCapacityRebalanceRequest> {
         &self.capacity_rebalance
-116
+    }
     /// Consumes the builder and constructs a [`FleetSpotMaintenanceStrategiesRequest`](crate::types::FleetSpotMaintenanceStrategiesRequest).
     pub fn build(self) -> crate::types::FleetSpotMaintenanceStrategiesRequest {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_flow_log.rs

@@ -87,87 +252,252 @@

↥ Expand context

     /// <p>The Amazon Resource Name (ARN) of the destination for the flow log data.</p>
     pub fn log_destination(&self) -> ::std::option::Option<&str> {
         self.log_destination.as_deref()
-90
+    }
     /// <p>The format of the flow log record.</p>
     pub fn log_format(&self) -> ::std::option::Option<&str> {
         self.log_format.as_deref()
-94
+    }
     /// <p>The tags for the flow log.</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()
-100
+    }
     /// <p>The maximum interval of time, in seconds, during which a flow of packets is captured and aggregated into a flow log record.</p>
     /// <p>When a network interface is attached to a <a href="https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html">Nitro-based instance</a>, the aggregation interval is always 60 seconds (1 minute) or less, regardless of the specified value.</p>
     /// <p>Valid Values: <code>60</code> | <code>600</code></p>
     pub fn max_aggregation_interval(&self) -> ::std::option::Option<i32> {
         self.max_aggregation_interval
-106
+    }

     /// <p>The destination options.</p>
     pub fn destination_options(&self) -> ::std::option::Option<&crate::types::DestinationOptionsResponse> {
         self.destination_options.as_ref()
-110
+    }
-111
+}
 static FLOWLOG_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog", "com.amazonaws.ec2", "FlowLog");
 static FLOWLOG_MEMBER_CREATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$CreationTime", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "creation_time",
     "CreationTime",
 ,
-119
+)
 .with_xml_name("creationTime");
 static FLOWLOG_MEMBER_DELIVER_LOGS_ERROR_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$DeliverLogsErrorMessage", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::String,
     "deliver_logs_error_message",
     "DeliverLogsErrorMessage",
 ,
-126
+)
 .with_xml_name("deliverLogsErrorMessage");
 static FLOWLOG_MEMBER_DELIVER_LOGS_PERMISSION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$DeliverLogsPermissionArn", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::String,
     "deliver_logs_permission_arn",
     "DeliverLogsPermissionArn",
 ,
-133
+)
 .with_xml_name("deliverLogsPermissionArn");
 static FLOWLOG_MEMBER_DELIVER_CROSS_ACCOUNT_ROLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$DeliverCrossAccountRole", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::String,
     "deliver_cross_account_role",
     "DeliverCrossAccountRole",
 ,
-140
+)
 .with_xml_name("deliverCrossAccountRole");
 static FLOWLOG_MEMBER_DELIVER_LOGS_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$DeliverLogsStatus", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::String,
     "deliver_logs_status",
     "DeliverLogsStatus",
 ,
-147
+)
 .with_xml_name("deliverLogsStatus");
 static FLOWLOG_MEMBER_FLOW_LOG_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$FlowLogId", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::String,
     "flow_log_id",
     "FlowLogId",
 ,
-154
+)
 .with_xml_name("flowLogId");
 static FLOWLOG_MEMBER_FLOW_LOG_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$FlowLogStatus", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::String,
     "flow_log_status",
     "FlowLogStatus",
 ,
-161
+)
 .with_xml_name("flowLogStatus");
 static FLOWLOG_MEMBER_LOG_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$LogGroupName", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::String,
     "log_group_name",
     "LogGroupName",
 ,
-168
+)
 .with_xml_name("logGroupName");
 static FLOWLOG_MEMBER_RESOURCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$ResourceId", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::String,
     "resource_id",
     "ResourceId",
 ,
-175
+)
 .with_xml_name("resourceId");
 static FLOWLOG_MEMBER_TRAFFIC_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$TrafficType", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::String,
     "traffic_type",
     "TrafficType",
 ,
-182
+)
 .with_xml_name("trafficType");
 static FLOWLOG_MEMBER_LOG_DESTINATION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$LogDestinationType", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::String,
     "log_destination_type",
     "LogDestinationType",
 ,
-189
+)
 .with_xml_name("logDestinationType");
 static FLOWLOG_MEMBER_LOG_DESTINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$LogDestination", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::String,
     "log_destination",
     "LogDestination",
 ,
-196
+)
 .with_xml_name("logDestination");
 static FLOWLOG_MEMBER_LOG_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$LogFormat", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::String,
     "log_format",
     "LogFormat",
 ,
-203
+)
 .with_xml_name("logFormat");
 static FLOWLOG_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$Tags", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-210
+)
 .with_xml_name("tagSet");
 static FLOWLOG_MEMBER_MAX_AGGREGATION_INTERVAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$MaxAggregationInterval", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_aggregation_interval",
     "MaxAggregationInterval",
 ,
-217
+)
 .with_xml_name("maxAggregationInterval");
 static FLOWLOG_MEMBER_DESTINATION_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FlowLog$DestinationOptions", "com.amazonaws.ec2", "FlowLog"),
     ::aws_smithy_schema::ShapeType::Structure,
     "destination_options",
     "DestinationOptions",
 ,
-224
+)
 .with_xml_name("destinationOptions");
 static FLOWLOG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FLOWLOG_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &FLOWLOG_MEMBER_CREATION_TIME,
         &FLOWLOG_MEMBER_DELIVER_LOGS_ERROR_MESSAGE,
         &FLOWLOG_MEMBER_DELIVER_LOGS_PERMISSION_ARN,

↧ Expand context

         &FLOWLOG_MEMBER_DELIVER_CROSS_ACCOUNT_ROLE,
         &FLOWLOG_MEMBER_DELIVER_LOGS_STATUS,
         &FLOWLOG_MEMBER_FLOW_LOG_ID,
         &FLOWLOG_MEMBER_FLOW_LOG_STATUS,
         &FLOWLOG_MEMBER_LOG_GROUP_NAME,
         &FLOWLOG_MEMBER_RESOURCE_ID,
         &FLOWLOG_MEMBER_TRAFFIC_TYPE,
         &FLOWLOG_MEMBER_LOG_DESTINATION_TYPE,
         &FLOWLOG_MEMBER_LOG_DESTINATION,
         &FLOWLOG_MEMBER_LOG_FORMAT,
         &FLOWLOG_MEMBER_TAGS,
         &FLOWLOG_MEMBER_MAX_AGGREGATION_INTERVAL,
         &FLOWLOG_MEMBER_DESTINATION_OPTIONS,
     ],
 );
 impl FlowLog {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLOWLOG_SCHEMA;
-251
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FlowLog {

@@ -286,286 +424,432 @@

↥ Expand context

             ser.write_string(&FLOWLOG_MEMBER_TRAFFIC_TYPE, val.as_str())?;
-287
+        }
         if let Some(ref val) = self.log_destination_type {
             ser.write_string(&FLOWLOG_MEMBER_LOG_DESTINATION_TYPE, val.as_str())?;
-290
+        }
         if let Some(ref val) = self.log_destination {
             ser.write_string(&FLOWLOG_MEMBER_LOG_DESTINATION, val)?;
-293
+        }
         if let Some(ref val) = self.log_format {
             ser.write_string(&FLOWLOG_MEMBER_LOG_FORMAT, val)?;
-296
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(&FLOWLOG_MEMBER_TAGS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                 for item in val {
                     ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-301
+                }
                 Ok(())
             })?;
-304
+        }
         if let Some(ref val) = self.max_aggregation_interval {

             ser.write_integer(&FLOWLOG_MEMBER_MAX_AGGREGATION_INTERVAL, *val)?;
-307
+        }
         if let Some(ref val) = self.destination_options {
             ser.write_struct(&FLOWLOG_MEMBER_DESTINATION_OPTIONS, val)?;
-310
+        }
         Ok(())
-312
+    }
-313
+}
 impl FlowLog {
     /// 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(&FLOWLOG_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FLOWLOG_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.creation_time = Some(deser.read_timestamp(member)?);
-332
+                }
                 Some(1) => {
                     builder.deliver_logs_error_message = Some(deser.read_string(member)?);
-335
+                }
                 Some(2) => {
                     builder.deliver_logs_permission_arn = Some(deser.read_string(member)?);
-338
+                }
                 Some(3) => {
                     builder.deliver_cross_account_role = Some(deser.read_string(member)?);
-341
+                }
                 Some(4) => {
                     builder.deliver_logs_status = Some(deser.read_string(member)?);
-344
+                }
                 Some(5) => {
                     builder.flow_log_id = Some(deser.read_string(member)?);
-347
+                }
                 Some(6) => {
                     builder.flow_log_status = Some(deser.read_string(member)?);
-350
+                }
                 Some(7) => {
                     builder.log_group_name = Some(deser.read_string(member)?);
-353
+                }
                 Some(8) => {
                     builder.resource_id = Some(deser.read_string(member)?);
-356
+                }
                 Some(9) => {
                     builder.traffic_type = Some(crate::types::TrafficType::from(deser.read_string(member)?.as_str()));
-359
+                }
                 Some(10) => {
                     builder.log_destination_type = Some(crate::types::LogDestinationType::from(deser.read_string(member)?.as_str()));
-362
+                }
                 Some(11) => {
                     builder.log_destination = Some(deser.read_string(member)?);
-365
+                }
                 Some(12) => {
                     builder.log_format = Some(deser.read_string(member)?);
-368
+                }
                 Some(13) => {
                     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
                     });
-378
+                }
                 Some(14) => {
                     builder.max_aggregation_interval = Some(deser.read_integer(member)?);
-381
+                }
                 Some(15) => {
                     builder.destination_options = Some(crate::types::DestinationOptionsResponse::deserialize(deser)?);
-384
+                }
                 _ => {}
-386
+            }
             Ok(())
         })?;
         Ok(builder.build())
-390
+    }
-391
+}
 impl FlowLog {
     /// 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 FlowLog {
     /// Creates a new builder-style object to manufacture [`FlowLog`](crate::types::FlowLog).
     pub fn builder() -> crate::types::builders::FlowLogBuilder {
         crate::types::builders::FlowLogBuilder::default()
-407
+    }
-408
+}
-409
 /// A builder for [`FlowLog`](crate::types::FlowLog).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FlowLogBuilder {
     pub(crate) creation_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) deliver_logs_error_message: ::std::option::Option<::std::string::String>,
     pub(crate) deliver_logs_permission_arn: ::std::option::Option<::std::string::String>,
     pub(crate) deliver_cross_account_role: ::std::option::Option<::std::string::String>,
     pub(crate) deliver_logs_status: ::std::option::Option<::std::string::String>,
     pub(crate) flow_log_id: ::std::option::Option<::std::string::String>,
     pub(crate) flow_log_status: ::std::option::Option<::std::string::String>,
     pub(crate) log_group_name: ::std::option::Option<::std::string::String>,
     pub(crate) resource_id: ::std::option::Option<::std::string::String>,
     pub(crate) traffic_type: ::std::option::Option<crate::types::TrafficType>,
     pub(crate) log_destination_type: ::std::option::Option<crate::types::LogDestinationType>,
     pub(crate) log_destination: ::std::option::Option<::std::string::String>,
     pub(crate) log_format: ::std::option::Option<::std::string::String>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) max_aggregation_interval: ::std::option::Option<i32>,
     pub(crate) destination_options: ::std::option::Option<crate::types::DestinationOptionsResponse>,
-430
+}
 impl FlowLogBuilder {
     /// <p>The date and time the flow log was created.</p>

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fpga_device_info.rs

@@ -9,9 +163,174 @@

↥ Expand context

     /// <p>The manufacturer of the FPGA accelerator.</p>
     pub manufacturer: ::std::option::Option<::std::string::String>,
     /// <p>The count of FPGA accelerators for the instance type.</p>
     pub count: ::std::option::Option<i32>,
     /// <p>Describes the memory for the FPGA accelerator for the instance type.</p>
     pub memory_info: ::std::option::Option<crate::types::FpgaDeviceMemoryInfo>,
-15
+}
 impl FpgaDeviceInfo {
     /// <p>The name of the FPGA accelerator.</p>
     pub fn name(&self) -> ::std::option::Option<&str> {
         self.name.as_deref()
-20
+    }
     /// <p>The manufacturer of the FPGA accelerator.</p>
     pub fn manufacturer(&self) -> ::std::option::Option<&str> {
         self.manufacturer.as_deref()
-24
+    }
     /// <p>The count of FPGA accelerators for the instance type.</p>
     pub fn count(&self) -> ::std::option::Option<i32> {
         self.count
-28
+    }

     /// <p>Describes the memory for the FPGA accelerator for the instance type.</p>
     pub fn memory_info(&self) -> ::std::option::Option<&crate::types::FpgaDeviceMemoryInfo> {
         self.memory_info.as_ref()
-32
+    }
-33
+}
 static FPGADEVICEINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaDeviceInfo", "com.amazonaws.ec2", "FpgaDeviceInfo");
 static FPGADEVICEINFO_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaDeviceInfo$Name", "com.amazonaws.ec2", "FpgaDeviceInfo"),
     ::aws_smithy_schema::ShapeType::String,
     "name",
     "Name",
 ,
-41
+)
 .with_xml_name("name");
 static FPGADEVICEINFO_MEMBER_MANUFACTURER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaDeviceInfo$Manufacturer", "com.amazonaws.ec2", "FpgaDeviceInfo"),
     ::aws_smithy_schema::ShapeType::String,
     "manufacturer",
     "Manufacturer",
 ,
-48
+)
 .with_xml_name("manufacturer");
 static FPGADEVICEINFO_MEMBER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaDeviceInfo$Count", "com.amazonaws.ec2", "FpgaDeviceInfo"),
     ::aws_smithy_schema::ShapeType::Integer,
     "count",
     "Count",
 ,
-55
+)
 .with_xml_name("count");
 static FPGADEVICEINFO_MEMBER_MEMORY_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaDeviceInfo$MemoryInfo", "com.amazonaws.ec2", "FpgaDeviceInfo"),
     ::aws_smithy_schema::ShapeType::Structure,
     "memory_info",
     "MemoryInfo",
 ,
-62
+)
 .with_xml_name("memoryInfo");
 static FPGADEVICEINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FPGADEVICEINFO_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &FPGADEVICEINFO_MEMBER_NAME,
         &FPGADEVICEINFO_MEMBER_MANUFACTURER,
         &FPGADEVICEINFO_MEMBER_COUNT,
         &FPGADEVICEINFO_MEMBER_MEMORY_INFO,
     ],
 );
 impl FpgaDeviceInfo {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FPGADEVICEINFO_SCHEMA;
-77
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FpgaDeviceInfo {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.name {
             ser.write_string(&FPGADEVICEINFO_MEMBER_NAME, val)?;
-86
+        }
         if let Some(ref val) = self.manufacturer {
             ser.write_string(&FPGADEVICEINFO_MEMBER_MANUFACTURER, val)?;
-89
+        }
         if let Some(ref val) = self.count {
             ser.write_integer(&FPGADEVICEINFO_MEMBER_COUNT, *val)?;
-92
+        }
         if let Some(ref val) = self.memory_info {
             ser.write_struct(&FPGADEVICEINFO_MEMBER_MEMORY_INFO, val)?;
-95
+        }
         Ok(())
-97
+    }
-98
+}
 impl FpgaDeviceInfo {
     /// 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(&FPGADEVICEINFO_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FPGADEVICEINFO_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.name = Some(deser.read_string(member)?);
-117
+                }
                 Some(1) => {
                     builder.manufacturer = Some(deser.read_string(member)?);
-120
+                }
                 Some(2) => {
                     builder.count = Some(deser.read_integer(member)?);
-123
+                }
                 Some(3) => {
                     builder.memory_info = Some(crate::types::FpgaDeviceMemoryInfo::deserialize(deser)?);
-126
+                }
                 _ => {}
-128
+            }
             Ok(())
         })?;
         Ok(builder.build())
-132
+    }
-133
+}
 impl FpgaDeviceInfo {
     /// 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 FpgaDeviceInfo {
     /// Creates a new builder-style object to manufacture [`FpgaDeviceInfo`](crate::types::FpgaDeviceInfo).
     pub fn builder() -> crate::types::builders::FpgaDeviceInfoBuilder {
         crate::types::builders::FpgaDeviceInfoBuilder::default()
-149
+    }
-150
+}
-151
 /// A builder for [`FpgaDeviceInfo`](crate::types::FpgaDeviceInfo).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FpgaDeviceInfoBuilder {
     pub(crate) name: ::std::option::Option<::std::string::String>,
     pub(crate) manufacturer: ::std::option::Option<::std::string::String>,
     pub(crate) count: ::std::option::Option<i32>,
     pub(crate) memory_info: ::std::option::Option<crate::types::FpgaDeviceMemoryInfo>,
-160
+}
 impl FpgaDeviceInfoBuilder {
     /// <p>The name of the FPGA accelerator.</p>
     pub fn name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.name = ::std::option::Option::Some(input.into());
         self
-166
+    }
     /// <p>The name of the FPGA accelerator.</p>
     pub fn set_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.name = input;
         self
-171
+    }
     /// <p>The name of the FPGA accelerator.</p>
     pub fn get_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.name

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fpga_device_memory_info.rs

@@ -1,1 +105,116 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Describes the memory for the FPGA accelerator for the instance type.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct FpgaDeviceMemoryInfo {
     /// <p>The size of the memory available to the FPGA accelerator, in MiB.</p>
     pub size_in_mib: ::std::option::Option<i32>,
-9
+}
 impl FpgaDeviceMemoryInfo {
     /// <p>The size of the memory available to the FPGA accelerator, in MiB.</p>
     pub fn size_in_mib(&self) -> ::std::option::Option<i32> {
         self.size_in_mib
-14
+    }

-15
+}
 static FPGADEVICEMEMORYINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaDeviceMemoryInfo", "com.amazonaws.ec2", "FpgaDeviceMemoryInfo");
 static FPGADEVICEMEMORYINFO_MEMBER_SIZE_IN_MIB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FpgaDeviceMemoryInfo$SizeInMiB",
         "com.amazonaws.ec2",
         "FpgaDeviceMemoryInfo",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "size_in_mib",
     "SizeInMiB",
 ,
-27
+)
 .with_xml_name("sizeInMiB");
 static FPGADEVICEMEMORYINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FPGADEVICEMEMORYINFO_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&FPGADEVICEMEMORYINFO_MEMBER_SIZE_IN_MIB],
 );
 impl FpgaDeviceMemoryInfo {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FPGADEVICEMEMORYINFO_SCHEMA;
-37
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FpgaDeviceMemoryInfo {
     #[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.size_in_mib {
             ser.write_integer(&FPGADEVICEMEMORYINFO_MEMBER_SIZE_IN_MIB, *val)?;
-46
+        }
         Ok(())
-48
+    }
-49
+}
 impl FpgaDeviceMemoryInfo {
     /// 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(&FPGADEVICEMEMORYINFO_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FPGADEVICEMEMORYINFO_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.size_in_mib = Some(deser.read_integer(member)?);
-68
+                }
                 _ => {}
-70
+            }
             Ok(())
         })?;
         Ok(builder.build())
-74
+    }
-75
+}
 impl FpgaDeviceMemoryInfo {
     /// 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 FpgaDeviceMemoryInfo {
     /// Creates a new builder-style object to manufacture [`FpgaDeviceMemoryInfo`](crate::types::FpgaDeviceMemoryInfo).
     pub fn builder() -> crate::types::builders::FpgaDeviceMemoryInfoBuilder {
         crate::types::builders::FpgaDeviceMemoryInfoBuilder::default()
-91
+    }
-92
+}
-93
 /// A builder for [`FpgaDeviceMemoryInfo`](crate::types::FpgaDeviceMemoryInfo).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FpgaDeviceMemoryInfoBuilder {
     pub(crate) size_in_mib: ::std::option::Option<i32>,
-99
+}
 impl FpgaDeviceMemoryInfoBuilder {
     /// <p>The size of the memory available to the FPGA accelerator, in MiB.</p>
     pub fn size_in_mib(mut self, input: i32) -> Self {
         self.size_in_mib = ::std::option::Option::Some(input);
         self
-105
+    }
     /// <p>The size of the memory available to the FPGA accelerator, in MiB.</p>
     pub fn set_size_in_mib(mut self, input: ::std::option::Option<i32>) -> Self {
         self.size_in_mib = input;
         self
-110
+    }
     /// <p>The size of the memory available to the FPGA accelerator, in MiB.</p>
     pub fn get_size_in_mib(&self) -> &::std::option::Option<i32> {
         &self.size_in_mib
-114
+    }
     /// Consumes the builder and constructs a [`FpgaDeviceMemoryInfo`](crate::types::FpgaDeviceMemoryInfo).
     pub fn build(self) -> crate::types::FpgaDeviceMemoryInfo {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fpga_image.rs

@@ -87,87 +252,252 @@

↥ Expand context

     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.product_codes.is_none()`.
     pub fn product_codes(&self) -> &[crate::types::ProductCode] {
         self.product_codes.as_deref().unwrap_or_default()
-90
+    }
     /// <p>Any tags assigned to the AFI.</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()
-96
+    }
     /// <p>Indicates whether the AFI is public.</p>
     pub fn public(&self) -> ::std::option::Option<bool> {
         self.public
-100
+    }
     /// <p>Indicates whether data retention support is enabled for the AFI.</p>
     pub fn data_retention_support(&self) -> ::std::option::Option<bool> {
         self.data_retention_support
-104
+    }
     /// <p>The instance types supported by the AFI.</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 `.instance_types.is_none()`.
     pub fn instance_types(&self) -> &[::std::string::String] {
         self.instance_types.as_deref().unwrap_or_default()
-110
+    }
-111
+}
 static FPGAIMAGE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage", "com.amazonaws.ec2", "FpgaImage");
 static FPGAIMAGE_MEMBER_FPGA_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$FpgaImageId", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::String,
     "fpga_image_id",
     "FpgaImageId",
 ,
-119
+)
 .with_xml_name("fpgaImageId");
 static FPGAIMAGE_MEMBER_FPGA_IMAGE_GLOBAL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$FpgaImageGlobalId", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::String,
     "fpga_image_global_id",
     "FpgaImageGlobalId",
 ,
-126
+)
 .with_xml_name("fpgaImageGlobalId");
 static FPGAIMAGE_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$Name", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::String,
     "name",
     "Name",
 ,
-133
+)
 .with_xml_name("name");
 static FPGAIMAGE_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$Description", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::String,
     "description",
     "Description",
 ,
-140
+)
 .with_xml_name("description");
 static FPGAIMAGE_MEMBER_SHELL_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$ShellVersion", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::String,
     "shell_version",
     "ShellVersion",
 ,
-147
+)
 .with_xml_name("shellVersion");
 static FPGAIMAGE_MEMBER_PCI_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$PciId", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::Structure,
     "pci_id",
     "PciId",
 ,
-154
+)
 .with_xml_name("pciId");
 static FPGAIMAGE_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$State", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::Structure,
     "state",
     "State",
 ,
-161
+)
 .with_xml_name("state");
 static FPGAIMAGE_MEMBER_CREATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$CreateTime", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "create_time",
     "CreateTime",
 ,
-168
+)
 .with_xml_name("createTime");
 static FPGAIMAGE_MEMBER_UPDATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$UpdateTime", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "update_time",
     "UpdateTime",
 ,
-175
+)
 .with_xml_name("updateTime");
 static FPGAIMAGE_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$OwnerId", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::String,
     "owner_id",
     "OwnerId",
 ,
-182
+)
 .with_xml_name("ownerId");
 static FPGAIMAGE_MEMBER_OWNER_ALIAS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$OwnerAlias", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::String,
     "owner_alias",
     "OwnerAlias",
 ,
-189
+)
 .with_xml_name("ownerAlias");
 static FPGAIMAGE_MEMBER_PRODUCT_CODES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$ProductCodes", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::List,
     "product_codes",
     "ProductCodes",
 ,
-196
+)
 .with_xml_name("productCodes");
 static FPGAIMAGE_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$Tags", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-203
+)
 .with_xml_name("tags");
 static FPGAIMAGE_MEMBER_PUBLIC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$Public", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::Boolean,
     "public",
     "Public",
 ,
-210
+)
 .with_xml_name("public");
 static FPGAIMAGE_MEMBER_DATA_RETENTION_SUPPORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$DataRetentionSupport", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::Boolean,
     "data_retention_support",
     "DataRetentionSupport",
 ,
-217
+)
 .with_xml_name("dataRetentionSupport");
 static FPGAIMAGE_MEMBER_INSTANCE_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImage$InstanceTypes", "com.amazonaws.ec2", "FpgaImage"),
     ::aws_smithy_schema::ShapeType::List,
     "instance_types",
     "InstanceTypes",
 ,
-224
+)
 .with_xml_name("instanceTypes");
 static FPGAIMAGE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FPGAIMAGE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &FPGAIMAGE_MEMBER_FPGA_IMAGE_ID,
         &FPGAIMAGE_MEMBER_FPGA_IMAGE_GLOBAL_ID,
         &FPGAIMAGE_MEMBER_NAME,

↧ Expand context

         &FPGAIMAGE_MEMBER_DESCRIPTION,
         &FPGAIMAGE_MEMBER_SHELL_VERSION,
         &FPGAIMAGE_MEMBER_PCI_ID,
         &FPGAIMAGE_MEMBER_STATE,
         &FPGAIMAGE_MEMBER_CREATE_TIME,
         &FPGAIMAGE_MEMBER_UPDATE_TIME,
         &FPGAIMAGE_MEMBER_OWNER_ID,
         &FPGAIMAGE_MEMBER_OWNER_ALIAS,
         &FPGAIMAGE_MEMBER_PRODUCT_CODES,
         &FPGAIMAGE_MEMBER_TAGS,
         &FPGAIMAGE_MEMBER_PUBLIC,
         &FPGAIMAGE_MEMBER_DATA_RETENTION_SUPPORT,
         &FPGAIMAGE_MEMBER_INSTANCE_TYPES,
     ],
 );
 impl FpgaImage {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FPGAIMAGE_SCHEMA;
-251
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FpgaImage {

@@ -302,302 +460,455 @@

↥ Expand context

         if let Some(ref val) = self.tags {
             ser.write_list(&FPGAIMAGE_MEMBER_TAGS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                 for item in val {
                     ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-306
+                }
                 Ok(())
             })?;
-309
+        }
         if let Some(ref val) = self.public {
             ser.write_boolean(&FPGAIMAGE_MEMBER_PUBLIC, *val)?;
-312
+        }
         if let Some(ref val) = self.data_retention_support {
             ser.write_boolean(&FPGAIMAGE_MEMBER_DATA_RETENTION_SUPPORT, *val)?;
-315
+        }
         if let Some(ref val) = self.instance_types {
             ser.write_list(
                 &FPGAIMAGE_MEMBER_INSTANCE_TYPES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;

-322
+                    }
                     Ok(())
                 },
             )?;
-326
+        }
         Ok(())
-328
+    }
-329
+}
 impl FpgaImage {
     /// 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(&FPGAIMAGE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FPGAIMAGE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.fpga_image_id = Some(deser.read_string(member)?);
-348
+                }
                 Some(1) => {
                     builder.fpga_image_global_id = Some(deser.read_string(member)?);
-351
+                }
                 Some(2) => {
                     builder.name = Some(deser.read_string(member)?);
-354
+                }
                 Some(3) => {
                     builder.description = Some(deser.read_string(member)?);
-357
+                }
                 Some(4) => {
                     builder.shell_version = Some(deser.read_string(member)?);
-360
+                }
                 Some(5) => {
                     builder.pci_id = Some(crate::types::PciId::deserialize(deser)?);
-363
+                }
                 Some(6) => {
                     builder.state = Some(crate::types::FpgaImageState::deserialize(deser)?);
-366
+                }
                 Some(7) => {
                     builder.create_time = Some(deser.read_timestamp(member)?);
-369
+                }
                 Some(8) => {
                     builder.update_time = Some(deser.read_timestamp(member)?);
-372
+                }
                 Some(9) => {
                     builder.owner_id = Some(deser.read_string(member)?);
-375
+                }
                 Some(10) => {
                     builder.owner_alias = Some(deser.read_string(member)?);
-378
+                }
                 Some(11) => {
                     builder.product_codes = 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::ProductCode::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ProductCode::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-388
+                }
                 Some(12) => {
                     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
                     });
-398
+                }
                 Some(13) => {
                     builder.public = Some(deser.read_boolean(member)?);
-401
+                }
                 Some(14) => {
                     builder.data_retention_support = Some(deser.read_boolean(member)?);
-404
+                }
                 Some(15) => {
                     builder.instance_types = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.instance_types = Some(deser.read_string_list(member)?);
-407
+                }
                 _ => {}
-409
+            }
             Ok(())
         })?;
         Ok(builder.build())
-413
+    }
-414
+}
 impl FpgaImage {
     /// 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 FpgaImage {
     /// Creates a new builder-style object to manufacture [`FpgaImage`](crate::types::FpgaImage).
     pub fn builder() -> crate::types::builders::FpgaImageBuilder {
         crate::types::builders::FpgaImageBuilder::default()
-430
+    }
-431
+}
-432
 /// A builder for [`FpgaImage`](crate::types::FpgaImage).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FpgaImageBuilder {
     pub(crate) fpga_image_id: ::std::option::Option<::std::string::String>,
     pub(crate) fpga_image_global_id: ::std::option::Option<::std::string::String>,
     pub(crate) name: ::std::option::Option<::std::string::String>,
     pub(crate) description: ::std::option::Option<::std::string::String>,
     pub(crate) shell_version: ::std::option::Option<::std::string::String>,
     pub(crate) pci_id: ::std::option::Option<crate::types::PciId>,
     pub(crate) state: ::std::option::Option<crate::types::FpgaImageState>,
     pub(crate) create_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) update_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) owner_id: ::std::option::Option<::std::string::String>,
     pub(crate) owner_alias: ::std::option::Option<::std::string::String>,
     pub(crate) product_codes: ::std::option::Option<::std::vec::Vec<crate::types::ProductCode>>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) public: ::std::option::Option<bool>,
     pub(crate) data_retention_support: ::std::option::Option<bool>,
     pub(crate) instance_types: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-453
+}
 impl FpgaImageBuilder {
     /// <p>The FPGA image identifier (AFI ID).</p>

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fpga_image_attribute.rs

@@ -23,23 +239,244 @@

↥ Expand context

     /// <p>The name of the AFI.</p>
     pub fn name(&self) -> ::std::option::Option<&str> {
         self.name.as_deref()
-26
+    }
     /// <p>The description of the AFI.</p>
     pub fn description(&self) -> ::std::option::Option<&str> {
         self.description.as_deref()
-30
+    }
     /// <p>The load permissions.</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 `.load_permissions.is_none()`.
     pub fn load_permissions(&self) -> &[crate::types::LoadPermission] {
         self.load_permissions.as_deref().unwrap_or_default()
-36
+    }
     /// <p>The product codes.</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 `.product_codes.is_none()`.
     pub fn product_codes(&self) -> &[crate::types::ProductCode] {
         self.product_codes.as_deref().unwrap_or_default()
-42
+    }

-43
+}
 static FPGAIMAGEATTRIBUTE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImageAttribute", "com.amazonaws.ec2", "FpgaImageAttribute");
 static FPGAIMAGEATTRIBUTE_MEMBER_FPGA_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FpgaImageAttribute$FpgaImageId",
         "com.amazonaws.ec2",
         "FpgaImageAttribute",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "fpga_image_id",
     "FpgaImageId",
 ,
-55
+)
 .with_xml_name("fpgaImageId");
 static FPGAIMAGEATTRIBUTE_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImageAttribute$Name", "com.amazonaws.ec2", "FpgaImageAttribute"),
     ::aws_smithy_schema::ShapeType::String,
     "name",
     "Name",
 ,
-62
+)
 .with_xml_name("name");
 static FPGAIMAGEATTRIBUTE_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FpgaImageAttribute$Description",
         "com.amazonaws.ec2",
         "FpgaImageAttribute",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "description",
     "Description",
 ,
-73
+)
 .with_xml_name("description");
 static FPGAIMAGEATTRIBUTE_MEMBER_LOAD_PERMISSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FpgaImageAttribute$LoadPermissions",
         "com.amazonaws.ec2",
         "FpgaImageAttribute",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "load_permissions",
     "LoadPermissions",
 ,
-84
+)
 .with_xml_name("loadPermissions");
 static FPGAIMAGEATTRIBUTE_MEMBER_PRODUCT_CODES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#FpgaImageAttribute$ProductCodes",
         "com.amazonaws.ec2",
         "FpgaImageAttribute",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "product_codes",
     "ProductCodes",
 ,
-95
+)
 .with_xml_name("productCodes");
 static FPGAIMAGEATTRIBUTE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FPGAIMAGEATTRIBUTE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &FPGAIMAGEATTRIBUTE_MEMBER_FPGA_IMAGE_ID,
         &FPGAIMAGEATTRIBUTE_MEMBER_NAME,
         &FPGAIMAGEATTRIBUTE_MEMBER_DESCRIPTION,
         &FPGAIMAGEATTRIBUTE_MEMBER_LOAD_PERMISSIONS,
         &FPGAIMAGEATTRIBUTE_MEMBER_PRODUCT_CODES,
     ],
 );
 impl FpgaImageAttribute {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FPGAIMAGEATTRIBUTE_SCHEMA;
-111
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FpgaImageAttribute {
     #[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.fpga_image_id {
             ser.write_string(&FPGAIMAGEATTRIBUTE_MEMBER_FPGA_IMAGE_ID, val)?;
-120
+        }
         if let Some(ref val) = self.name {
             ser.write_string(&FPGAIMAGEATTRIBUTE_MEMBER_NAME, val)?;
-123
+        }
         if let Some(ref val) = self.description {
             ser.write_string(&FPGAIMAGEATTRIBUTE_MEMBER_DESCRIPTION, val)?;
-126
+        }
         if let Some(ref val) = self.load_permissions {
             ser.write_list(
                 &FPGAIMAGEATTRIBUTE_MEMBER_LOAD_PERMISSIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::LoadPermission::SCHEMA, item)?;
-133
+                    }
                     Ok(())
                 },
             )?;
-137
+        }
         if let Some(ref val) = self.product_codes {
             ser.write_list(
                 &FPGAIMAGEATTRIBUTE_MEMBER_PRODUCT_CODES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::ProductCode::SCHEMA, item)?;
-144
+                    }
                     Ok(())
                 },
             )?;
-148
+        }
         Ok(())
-150
+    }
-151
+}
 impl FpgaImageAttribute {
     /// 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(&FPGAIMAGEATTRIBUTE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FPGAIMAGEATTRIBUTE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.fpga_image_id = Some(deser.read_string(member)?);
-170
+                }
                 Some(1) => {
                     builder.name = Some(deser.read_string(member)?);
-173
+                }
                 Some(2) => {
                     builder.description = Some(deser.read_string(member)?);
-176
+                }
                 Some(3) => {
                     builder.load_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::LoadPermission::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::LoadPermission::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-186
+                }
                 Some(4) => {
                     builder.product_codes = 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::ProductCode::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ProductCode::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-196
+                }
                 _ => {}
-198
+            }
             Ok(())
         })?;
         Ok(builder.build())
-202
+    }
-203
+}
 impl FpgaImageAttribute {
     /// 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 FpgaImageAttribute {
     /// Creates a new builder-style object to manufacture [`FpgaImageAttribute`](crate::types::FpgaImageAttribute).
     pub fn builder() -> crate::types::builders::FpgaImageAttributeBuilder {
         crate::types::builders::FpgaImageAttributeBuilder::default()
-219
+    }
-220
+}
-221
 /// A builder for [`FpgaImageAttribute`](crate::types::FpgaImageAttribute).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FpgaImageAttributeBuilder {
     pub(crate) fpga_image_id: ::std::option::Option<::std::string::String>,
     pub(crate) name: ::std::option::Option<::std::string::String>,
     pub(crate) description: ::std::option::Option<::std::string::String>,
     pub(crate) load_permissions: ::std::option::Option<::std::vec::Vec<crate::types::LoadPermission>>,
     pub(crate) product_codes: ::std::option::Option<::std::vec::Vec<crate::types::ProductCode>>,
-231
+}
 impl FpgaImageAttributeBuilder {
     /// <p>The ID of the AFI.</p>
     pub fn fpga_image_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.fpga_image_id = ::std::option::Option::Some(input.into());
         self
-237
+    }
     /// <p>The ID of the AFI.</p>
     pub fn set_fpga_image_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.fpga_image_id = input;
         self
-242
+    }
     /// <p>The ID of the AFI.</p>
     pub fn get_fpga_image_id(&self) -> &::std::option::Option<::std::string::String> {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fpga_image_state.rs

@@ -17,17 +140,151 @@

↥ Expand context

     /// </ul>
     pub code: ::std::option::Option<crate::types::FpgaImageStateCode>,
     /// <p>If the state is <code>failed</code>, this is the error message.</p>
     pub message: ::std::option::Option<::std::string::String>,
-21
+}
 impl FpgaImageState {
     /// <p>The state. The following are the possible values:</p>
     /// <ul>
     /// <li>
     /// <p><code>pending</code> - AFI bitstream generation is in progress.</p></li>
     /// <li>
     /// <p><code>available</code> - The AFI is available for use.</p></li>
     /// <li>
     /// <p><code>failed</code> - AFI bitstream generation failed.</p></li>
     /// <li>
     /// <p><code>unavailable</code> - The AFI is no longer available for use.</p></li>
     /// </ul>
     pub fn code(&self) -> ::std::option::Option<&crate::types::FpgaImageStateCode> {
         self.code.as_ref()
-36
+    }

     /// <p>If the state is <code>failed</code>, this is the error message.</p>
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-40
+    }
-41
+}
 static FPGAIMAGESTATE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImageState", "com.amazonaws.ec2", "FpgaImageState");
 static FPGAIMAGESTATE_MEMBER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImageState$Code", "com.amazonaws.ec2", "FpgaImageState"),
     ::aws_smithy_schema::ShapeType::String,
     "code",
     "Code",
 ,
-49
+)
 .with_xml_name("code");
 static FPGAIMAGESTATE_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaImageState$Message", "com.amazonaws.ec2", "FpgaImageState"),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
-56
+)
 .with_xml_name("message");
 static FPGAIMAGESTATE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FPGAIMAGESTATE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&FPGAIMAGESTATE_MEMBER_CODE, &FPGAIMAGESTATE_MEMBER_MESSAGE],
 );
 impl FpgaImageState {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FPGAIMAGESTATE_SCHEMA;
-66
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FpgaImageState {
     #[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.code {
             ser.write_string(&FPGAIMAGESTATE_MEMBER_CODE, val.as_str())?;
-75
+        }
         if let Some(ref val) = self.message {
             ser.write_string(&FPGAIMAGESTATE_MEMBER_MESSAGE, val)?;
-78
+        }
         Ok(())
-80
+    }
-81
+}
 impl FpgaImageState {
     /// 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(&FPGAIMAGESTATE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FPGAIMAGESTATE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.code = Some(crate::types::FpgaImageStateCode::from(deser.read_string(member)?.as_str()));
-100
+                }
                 Some(1) => {
                     builder.message = Some(deser.read_string(member)?);
-103
+                }
                 _ => {}
-105
+            }
             Ok(())
         })?;
         Ok(builder.build())
-109
+    }
-110
+}
 impl FpgaImageState {
     /// 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 FpgaImageState {
     /// Creates a new builder-style object to manufacture [`FpgaImageState`](crate::types::FpgaImageState).
     pub fn builder() -> crate::types::builders::FpgaImageStateBuilder {
         crate::types::builders::FpgaImageStateBuilder::default()
-126
+    }
-127
+}
-128
 /// A builder for [`FpgaImageState`](crate::types::FpgaImageState).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FpgaImageStateBuilder {
     pub(crate) code: ::std::option::Option<crate::types::FpgaImageStateCode>,
     pub(crate) message: ::std::option::Option<::std::string::String>,
-135
+}
 impl FpgaImageStateBuilder {
     /// <p>The state. The following are the possible values:</p>
     /// <ul>
     /// <li>
     /// <p><code>pending</code> - AFI bitstream generation is in progress.</p></li>
     /// <li>
     /// <p><code>available</code> - The AFI is available for use.</p></li>
     /// <li>
     /// <p><code>failed</code> - AFI bitstream generation failed.</p></li>
     /// <li>
     /// <p><code>unavailable</code> - The AFI is no longer available for use.</p></li>
     /// </ul>
     pub fn code(mut self, input: crate::types::FpgaImageStateCode) -> Self {
         self.code = ::std::option::Option::Some(input);
         self
-151
+    }

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_fpga_info.rs

@@ -1,1 +137,145 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Describes the FPGAs for the instance type.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct FpgaInfo {
     /// <p>Describes the FPGAs for the instance type.</p>
     pub fpgas: ::std::option::Option<::std::vec::Vec<crate::types::FpgaDeviceInfo>>,
     /// <p>The total memory of all FPGA accelerators for the instance type.</p>
     pub total_fpga_memory_in_mib: ::std::option::Option<i32>,
-11
+}
 impl FpgaInfo {
     /// <p>Describes the FPGAs for the instance type.</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 `.fpgas.is_none()`.
     pub fn fpgas(&self) -> &[crate::types::FpgaDeviceInfo] {
         self.fpgas.as_deref().unwrap_or_default()
-18
+    }

     /// <p>The total memory of all FPGA accelerators for the instance type.</p>
     pub fn total_fpga_memory_in_mib(&self) -> ::std::option::Option<i32> {
         self.total_fpga_memory_in_mib
-22
+    }
-23
+}
 static FPGAINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaInfo", "com.amazonaws.ec2", "FpgaInfo");
 static FPGAINFO_MEMBER_FPGAS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaInfo$Fpgas", "com.amazonaws.ec2", "FpgaInfo"),
     ::aws_smithy_schema::ShapeType::List,
     "fpgas",
     "Fpgas",
 ,
-31
+)
 .with_xml_name("fpgas");
 static FPGAINFO_MEMBER_TOTAL_FPGA_MEMORY_IN_MIB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FpgaInfo$TotalFpgaMemoryInMiB", "com.amazonaws.ec2", "FpgaInfo"),
     ::aws_smithy_schema::ShapeType::Integer,
     "total_fpga_memory_in_mib",
     "TotalFpgaMemoryInMiB",
 ,
-38
+)
 .with_xml_name("totalFpgaMemoryInMiB");
 static FPGAINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FPGAINFO_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&FPGAINFO_MEMBER_FPGAS, &FPGAINFO_MEMBER_TOTAL_FPGA_MEMORY_IN_MIB],
 );
 impl FpgaInfo {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FPGAINFO_SCHEMA;
-48
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FpgaInfo {
     #[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.fpgas {
             ser.write_list(&FPGAINFO_MEMBER_FPGAS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                 for item in val {
                     ser.write_struct(crate::types::FpgaDeviceInfo::SCHEMA, item)?;
-59
+                }
                 Ok(())
             })?;
-62
+        }
         if let Some(ref val) = self.total_fpga_memory_in_mib {
             ser.write_integer(&FPGAINFO_MEMBER_TOTAL_FPGA_MEMORY_IN_MIB, *val)?;
-65
+        }
         Ok(())
-67
+    }
-68
+}
 impl FpgaInfo {
     /// 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(&FPGAINFO_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FPGAINFO_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.fpgas = 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::FpgaDeviceInfo::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::FpgaDeviceInfo::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-94
+                }
                 Some(1) => {
                     builder.total_fpga_memory_in_mib = Some(deser.read_integer(member)?);
-97
+                }
                 _ => {}
-99
+            }
             Ok(())
         })?;
         Ok(builder.build())
-103
+    }
-104
+}
 impl FpgaInfo {
     /// 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 FpgaInfo {
     /// Creates a new builder-style object to manufacture [`FpgaInfo`](crate::types::FpgaInfo).
     pub fn builder() -> crate::types::builders::FpgaInfoBuilder {
         crate::types::builders::FpgaInfoBuilder::default()
-120
+    }
-121
+}
-122
 /// A builder for [`FpgaInfo`](crate::types::FpgaInfo).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FpgaInfoBuilder {
     pub(crate) fpgas: ::std::option::Option<::std::vec::Vec<crate::types::FpgaDeviceInfo>>,
     pub(crate) total_fpga_memory_in_mib: ::std::option::Option<i32>,
-129
+}
 impl FpgaInfoBuilder {
     /// Appends an item to `fpgas`.
     ///
     /// To override the contents of this collection use [`set_fpgas`](Self::set_fpgas).
     ///
     /// <p>Describes the FPGAs for the instance type.</p>
     pub fn fpgas(mut self, input: crate::types::FpgaDeviceInfo) -> Self {
         let mut v = self.fpgas.unwrap_or_default();
         v.push(input);
         self.fpgas = ::std::option::Option::Some(v);
         self
-141
+    }
     /// <p>Describes the FPGAs for the instance type.</p>
     pub fn set_fpgas(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::FpgaDeviceInfo>>) -> Self {
         self.fpgas = input;
         self

AWS SDK

Files changed: