AWS SDK

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

@@ -108,108 +322,322 @@

 impl ::std::fmt::Debug for LaunchSpecification {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("LaunchSpecification");
         formatter.field("user_data", &"*** Sensitive Data Redacted ***");
         formatter.field("addressing_type", &self.addressing_type);
         formatter.field("block_device_mappings", &self.block_device_mappings);
         formatter.field("ebs_optimized", &self.ebs_optimized);
         formatter.field("iam_instance_profile", &self.iam_instance_profile);
         formatter.field("image_id", &self.image_id);
         formatter.field("instance_type", &self.instance_type);
         formatter.field("kernel_id", &self.kernel_id);
         formatter.field("key_name", &self.key_name);
         formatter.field("network_interfaces", &self.network_interfaces);
         formatter.field("placement", &self.placement);
         formatter.field("ramdisk_id", &self.ramdisk_id);
         formatter.field("subnet_id", &self.subnet_id);
         formatter.field("security_groups", &self.security_groups);
         formatter.field("monitoring", &self.monitoring);
         formatter.finish()
-127
+    }

-128
+}
 static LAUNCHSPECIFICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#LaunchSpecification", "com.amazonaws.ec2", "LaunchSpecification");
 static LAUNCHSPECIFICATION_MEMBER_USER_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$UserData",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "user_data",
     "UserData",
 ,
-140
+)
 .with_xml_name("userData");
 static LAUNCHSPECIFICATION_MEMBER_ADDRESSING_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$AddressingType",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "addressing_type",
     "AddressingType",
 ,
-151
+)
 .with_xml_name("addressingType");
 static LAUNCHSPECIFICATION_MEMBER_BLOCK_DEVICE_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$BlockDeviceMappings",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "block_device_mappings",
     "BlockDeviceMappings",
 ,
-162
+)
 .with_xml_name("blockDeviceMapping");
 static LAUNCHSPECIFICATION_MEMBER_EBS_OPTIMIZED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$EbsOptimized",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "ebs_optimized",
     "EbsOptimized",
 ,
-173
+)
 .with_xml_name("ebsOptimized");
 static LAUNCHSPECIFICATION_MEMBER_IAM_INSTANCE_PROFILE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$IamInstanceProfile",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "iam_instance_profile",
     "IamInstanceProfile",
 ,
-184
+)
 .with_xml_name("iamInstanceProfile");
 static LAUNCHSPECIFICATION_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$ImageId",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "image_id",
     "ImageId",
 ,
-195
+)
 .with_xml_name("imageId");
 static LAUNCHSPECIFICATION_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$InstanceType",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_type",
     "InstanceType",
 ,
-206
+)
 .with_xml_name("instanceType");
 static LAUNCHSPECIFICATION_MEMBER_KERNEL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$KernelId",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "kernel_id",
     "KernelId",
 ,
-217
+)
 .with_xml_name("kernelId");
 static LAUNCHSPECIFICATION_MEMBER_KEY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$KeyName",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key_name",
     "KeyName",
 ,
-228
+)
 .with_xml_name("keyName");
 static LAUNCHSPECIFICATION_MEMBER_NETWORK_INTERFACES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$NetworkInterfaces",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "network_interfaces",
     "NetworkInterfaces",
 ,
-239
+)
 .with_xml_name("networkInterfaceSet");
 static LAUNCHSPECIFICATION_MEMBER_PLACEMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$Placement",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "placement",
     "Placement",
 ,
-250
+)
 .with_xml_name("placement");
 static LAUNCHSPECIFICATION_MEMBER_RAMDISK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$RamdiskId",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ramdisk_id",
     "RamdiskId",
 ,
-261
+)
 .with_xml_name("ramdiskId");
 static LAUNCHSPECIFICATION_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$SubnetId",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "subnet_id",
     "SubnetId",
 ,
-272
+)
 .with_xml_name("subnetId");
 static LAUNCHSPECIFICATION_MEMBER_SECURITY_GROUPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$SecurityGroups",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "security_groups",
     "SecurityGroups",
 ,
-283
+)
 .with_xml_name("groupSet");
 static LAUNCHSPECIFICATION_MEMBER_MONITORING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchSpecification$Monitoring",
         "com.amazonaws.ec2",
         "LaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "monitoring",
     "Monitoring",
 ,
-294
+)
 .with_xml_name("monitoring");
 static LAUNCHSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHSPECIFICATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHSPECIFICATION_MEMBER_USER_DATA,
         &LAUNCHSPECIFICATION_MEMBER_ADDRESSING_TYPE,
         &LAUNCHSPECIFICATION_MEMBER_BLOCK_DEVICE_MAPPINGS,

↧ Expand context

         &LAUNCHSPECIFICATION_MEMBER_EBS_OPTIMIZED,
         &LAUNCHSPECIFICATION_MEMBER_IAM_INSTANCE_PROFILE,
         &LAUNCHSPECIFICATION_MEMBER_IMAGE_ID,
         &LAUNCHSPECIFICATION_MEMBER_INSTANCE_TYPE,
         &LAUNCHSPECIFICATION_MEMBER_KERNEL_ID,
         &LAUNCHSPECIFICATION_MEMBER_KEY_NAME,
         &LAUNCHSPECIFICATION_MEMBER_NETWORK_INTERFACES,
         &LAUNCHSPECIFICATION_MEMBER_PLACEMENT,
         &LAUNCHSPECIFICATION_MEMBER_RAMDISK_ID,
         &LAUNCHSPECIFICATION_MEMBER_SUBNET_ID,
         &LAUNCHSPECIFICATION_MEMBER_SECURITY_GROUPS,
         &LAUNCHSPECIFICATION_MEMBER_MONITORING,
     ],
 );
 impl LaunchSpecification {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHSPECIFICATION_SCHEMA;
-320
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchSpecification {
     #[allow(unused_variables, clippy::diverging_sub_expression)]

@@ -371,371 +526,528 @@

↥ Expand context

             )?;
-372
+        }
         if let Some(ref val) = self.placement {
             ser.write_struct(&LAUNCHSPECIFICATION_MEMBER_PLACEMENT, val)?;
-375
+        }
         if let Some(ref val) = self.ramdisk_id {
             ser.write_string(&LAUNCHSPECIFICATION_MEMBER_RAMDISK_ID, val)?;
-378
+        }
         if let Some(ref val) = self.subnet_id {
             ser.write_string(&LAUNCHSPECIFICATION_MEMBER_SUBNET_ID, val)?;
-381
+        }
         if let Some(ref val) = self.security_groups {
             ser.write_list(
                 &LAUNCHSPECIFICATION_MEMBER_SECURITY_GROUPS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::GroupIdentifier::SCHEMA, item)?;
-388
+                    }
                     Ok(())
                 },

             )?;
-392
+        }
         if let Some(ref val) = self.monitoring {
             ser.write_struct(&LAUNCHSPECIFICATION_MEMBER_MONITORING, val)?;
-395
+        }
         Ok(())
-397
+    }
-398
+}
 impl LaunchSpecification {
     /// 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(&LAUNCHSPECIFICATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHSPECIFICATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.user_data = Some(deser.read_string(member)?);
-417
+                }
                 Some(1) => {
                     builder.addressing_type = Some(deser.read_string(member)?);
-420
+                }
                 Some(2) => {
                     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::BlockDeviceMapping::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::BlockDeviceMapping::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-430
+                }
                 Some(3) => {
                     builder.ebs_optimized = Some(deser.read_boolean(member)?);
-433
+                }
                 Some(4) => {
                     builder.iam_instance_profile = Some(crate::types::IamInstanceProfileSpecification::deserialize(deser)?);
-436
+                }
                 Some(5) => {
                     builder.image_id = Some(deser.read_string(member)?);
-439
+                }
                 Some(6) => {
                     builder.instance_type = Some(crate::types::InstanceType::from(deser.read_string(member)?.as_str()));
-442
+                }
                 Some(7) => {
                     builder.kernel_id = Some(deser.read_string(member)?);
-445
+                }
                 Some(8) => {
                     builder.key_name = Some(deser.read_string(member)?);
-448
+                }
                 Some(9) => {
                     builder.network_interfaces = 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::InstanceNetworkInterfaceSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::InstanceNetworkInterfaceSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-458
+                }
                 Some(10) => {
                     builder.placement = Some(crate::types::SpotPlacement::deserialize(deser)?);
-461
+                }
                 Some(11) => {
                     builder.ramdisk_id = Some(deser.read_string(member)?);
-464
+                }
                 Some(12) => {
                     builder.subnet_id = Some(deser.read_string(member)?);
-467
+                }
                 Some(13) => {
                     builder.security_groups = 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::GroupIdentifier::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::GroupIdentifier::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-477
+                }
                 Some(14) => {
                     builder.monitoring = Some(crate::types::RunInstancesMonitoringEnabled::deserialize(deser)?);
-480
+                }
                 _ => {}
-482
+            }
             Ok(())
         })?;
         Ok(builder.build())
-486
+    }
-487
+}
 impl LaunchSpecification {
     /// 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 LaunchSpecification {
     /// Creates a new builder-style object to manufacture [`LaunchSpecification`](crate::types::LaunchSpecification).
     pub fn builder() -> crate::types::builders::LaunchSpecificationBuilder {
         crate::types::builders::LaunchSpecificationBuilder::default()
-503
+    }
-504
+}
-505
 /// A builder for [`LaunchSpecification`](crate::types::LaunchSpecification).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchSpecificationBuilder {
     pub(crate) user_data: ::std::option::Option<::std::string::String>,
     pub(crate) addressing_type: ::std::option::Option<::std::string::String>,
     pub(crate) block_device_mappings: ::std::option::Option<::std::vec::Vec<crate::types::BlockDeviceMapping>>,
     pub(crate) ebs_optimized: ::std::option::Option<bool>,
     pub(crate) iam_instance_profile: ::std::option::Option<crate::types::IamInstanceProfileSpecification>,
     pub(crate) image_id: ::std::option::Option<::std::string::String>,
     pub(crate) instance_type: ::std::option::Option<crate::types::InstanceType>,
     pub(crate) kernel_id: ::std::option::Option<::std::string::String>,
     pub(crate) key_name: ::std::option::Option<::std::string::String>,
     pub(crate) network_interfaces: ::std::option::Option<::std::vec::Vec<crate::types::InstanceNetworkInterfaceSpecification>>,
     pub(crate) placement: ::std::option::Option<crate::types::SpotPlacement>,
     pub(crate) ramdisk_id: ::std::option::Option<::std::string::String>,
     pub(crate) subnet_id: ::std::option::Option<::std::string::String>,
     pub(crate) security_groups: ::std::option::Option<::std::vec::Vec<crate::types::GroupIdentifier>>,
     pub(crate) monitoring: ::std::option::Option<crate::types::RunInstancesMonitoringEnabled>,
-525
+}
 impl LaunchSpecificationBuilder {
     /// <p>The base64-encoded user data that instances use when starting up. User data is limited to 16 KB.</p>
     pub fn user_data(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {

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

@@ -35,35 +156,156 @@

↥ Expand context

         self.create_time.as_ref()
-36
+    }
     /// <p>The principal that created the launch template.</p>
     pub fn created_by(&self) -> ::std::option::Option<&str> {
         self.created_by.as_deref()
-40
+    }
     /// <p>The version number of the default version of the launch template.</p>
     pub fn default_version_number(&self) -> ::std::option::Option<i64> {
         self.default_version_number
-44
+    }
     /// <p>The version number of the latest version of the launch template.</p>
     pub fn latest_version_number(&self) -> ::std::option::Option<i64> {
         self.latest_version_number
-48
+    }
     /// <p>The tags for the launch template.</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()
-54
+    }

     /// <p>The entity that manages the launch template.</p>
     pub fn operator(&self) -> ::std::option::Option<&crate::types::OperatorResponse> {
         self.operator.as_ref()
-58
+    }
-59
+}
 static LAUNCHTEMPLATE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#LaunchTemplate", "com.amazonaws.ec2", "LaunchTemplate");
 static LAUNCHTEMPLATE_MEMBER_LAUNCH_TEMPLATE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#LaunchTemplate$LaunchTemplateId", "com.amazonaws.ec2", "LaunchTemplate"),
     ::aws_smithy_schema::ShapeType::String,
     "launch_template_id",
     "LaunchTemplateId",
 ,
-67
+)
 .with_xml_name("launchTemplateId");
 static LAUNCHTEMPLATE_MEMBER_LAUNCH_TEMPLATE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplate$LaunchTemplateName",
         "com.amazonaws.ec2",
         "LaunchTemplate",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "launch_template_name",
     "LaunchTemplateName",
 ,
-78
+)
 .with_xml_name("launchTemplateName");
 static LAUNCHTEMPLATE_MEMBER_CREATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#LaunchTemplate$CreateTime", "com.amazonaws.ec2", "LaunchTemplate"),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "create_time",
     "CreateTime",
 ,
-85
+)
 .with_xml_name("createTime");
 static LAUNCHTEMPLATE_MEMBER_CREATED_BY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#LaunchTemplate$CreatedBy", "com.amazonaws.ec2", "LaunchTemplate"),
     ::aws_smithy_schema::ShapeType::String,
     "created_by",
     "CreatedBy",
 ,
-92
+)
 .with_xml_name("createdBy");
 static LAUNCHTEMPLATE_MEMBER_DEFAULT_VERSION_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplate$DefaultVersionNumber",
         "com.amazonaws.ec2",
         "LaunchTemplate",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "default_version_number",
     "DefaultVersionNumber",
 ,
-103
+)
 .with_xml_name("defaultVersionNumber");
 static LAUNCHTEMPLATE_MEMBER_LATEST_VERSION_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplate$LatestVersionNumber",
         "com.amazonaws.ec2",
         "LaunchTemplate",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "latest_version_number",
     "LatestVersionNumber",
 ,
-114
+)
 .with_xml_name("latestVersionNumber");
 static LAUNCHTEMPLATE_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#LaunchTemplate$Tags", "com.amazonaws.ec2", "LaunchTemplate"),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-121
+)
 .with_xml_name("tagSet");
 static LAUNCHTEMPLATE_MEMBER_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#LaunchTemplate$Operator", "com.amazonaws.ec2", "LaunchTemplate"),
     ::aws_smithy_schema::ShapeType::Structure,
     "operator",
     "Operator",
 ,
-128
+)
 .with_xml_name("operator");
 static LAUNCHTEMPLATE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATE_MEMBER_LAUNCH_TEMPLATE_ID,
         &LAUNCHTEMPLATE_MEMBER_LAUNCH_TEMPLATE_NAME,
         &LAUNCHTEMPLATE_MEMBER_CREATE_TIME,

↧ Expand context

         &LAUNCHTEMPLATE_MEMBER_CREATED_BY,
         &LAUNCHTEMPLATE_MEMBER_DEFAULT_VERSION_NUMBER,
         &LAUNCHTEMPLATE_MEMBER_LATEST_VERSION_NUMBER,
         &LAUNCHTEMPLATE_MEMBER_TAGS,
         &LAUNCHTEMPLATE_MEMBER_OPERATOR,
     ],
 );
 impl LaunchTemplate {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATE_SCHEMA;
-147
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplate {
     #[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(&LAUNCHTEMPLATE_MEMBER_LAUNCH_TEMPLATE_ID, val)?;
-156
+        }

@@ -161,161 +275,283 @@

↥ Expand context

             ser.write_timestamp(&LAUNCHTEMPLATE_MEMBER_CREATE_TIME, val)?;
-162
+        }
         if let Some(ref val) = self.created_by {
             ser.write_string(&LAUNCHTEMPLATE_MEMBER_CREATED_BY, val)?;
-165
+        }
         if let Some(ref val) = self.default_version_number {
             ser.write_long(&LAUNCHTEMPLATE_MEMBER_DEFAULT_VERSION_NUMBER, *val)?;
-168
+        }
         if let Some(ref val) = self.latest_version_number {
             ser.write_long(&LAUNCHTEMPLATE_MEMBER_LATEST_VERSION_NUMBER, *val)?;
-171
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &LAUNCHTEMPLATE_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-178
+                    }
                     Ok(())
                 },

             )?;
-182
+        }
         if let Some(ref val) = self.operator {
             ser.write_struct(&LAUNCHTEMPLATE_MEMBER_OPERATOR, val)?;
-185
+        }
         Ok(())
-187
+    }
-188
+}
 impl LaunchTemplate {
     /// 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(&LAUNCHTEMPLATE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.launch_template_id = Some(deser.read_string(member)?);
-207
+                }
                 Some(1) => {
                     builder.launch_template_name = Some(deser.read_string(member)?);
-210
+                }
                 Some(2) => {
                     builder.create_time = Some(deser.read_timestamp(member)?);
-213
+                }
                 Some(3) => {
                     builder.created_by = Some(deser.read_string(member)?);
-216
+                }
                 Some(4) => {
                     builder.default_version_number = Some(deser.read_long(member)?);
-219
+                }
                 Some(5) => {
                     builder.latest_version_number = Some(deser.read_long(member)?);
-222
+                }
                 Some(6) => {
                     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
                     });
-232
+                }
                 Some(7) => {
                     builder.operator = Some(crate::types::OperatorResponse::deserialize(deser)?);
-235
+                }
                 _ => {}
-237
+            }
             Ok(())
         })?;
         Ok(builder.build())
-241
+    }
-242
+}
 impl LaunchTemplate {
     /// 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 LaunchTemplate {
     /// Creates a new builder-style object to manufacture [`LaunchTemplate`](crate::types::LaunchTemplate).
     pub fn builder() -> crate::types::builders::LaunchTemplateBuilder {
         crate::types::builders::LaunchTemplateBuilder::default()
-258
+    }
-259
+}
-260
 /// A builder for [`LaunchTemplate`](crate::types::LaunchTemplate).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateBuilder {
     pub(crate) launch_template_id: ::std::option::Option<::std::string::String>,
     pub(crate) launch_template_name: ::std::option::Option<::std::string::String>,
     pub(crate) create_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) created_by: ::std::option::Option<::std::string::String>,
     pub(crate) default_version_number: ::std::option::Option<i64>,
     pub(crate) latest_version_number: ::std::option::Option<i64>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) operator: ::std::option::Option<crate::types::OperatorResponse>,
-273
+}
 impl LaunchTemplateBuilder {
     /// <p>The ID of the launch template.</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
-279
+    }
     /// <p>The ID of the launch template.</p>
     pub fn set_launch_template_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.launch_template_id = input;
         self

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

@@ -5,5 +135,146 @@

↥ Expand context

 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct LaunchTemplateAndOverridesResponse {
     /// <p>The launch template.</p>
     pub launch_template_specification: ::std::option::Option<crate::types::FleetLaunchTemplateSpecification>,
     /// <p>Any parameters that you specify override the same parameters in the launch template.</p>
     pub overrides: ::std::option::Option<crate::types::FleetLaunchTemplateOverrides>,
-11
+}
 impl LaunchTemplateAndOverridesResponse {
     /// <p>The launch template.</p>
     pub fn launch_template_specification(&self) -> ::std::option::Option<&crate::types::FleetLaunchTemplateSpecification> {
         self.launch_template_specification.as_ref()
-16
+    }
     /// <p>Any parameters that you specify override the same parameters in the launch template.</p>
     pub fn overrides(&self) -> ::std::option::Option<&crate::types::FleetLaunchTemplateOverrides> {
         self.overrides.as_ref()
-20
+    }
-21
+}
 static LAUNCHTEMPLATEANDOVERRIDESRESPONSE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#LaunchTemplateAndOverridesResponse",
     "com.amazonaws.ec2",

     "LaunchTemplateAndOverridesResponse",
 );
 static LAUNCHTEMPLATEANDOVERRIDESRESPONSE_MEMBER_LAUNCH_TEMPLATE_SPECIFICATION: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2#LaunchTemplateAndOverridesResponse$LaunchTemplateSpecification",
             "com.amazonaws.ec2",
             "LaunchTemplateAndOverridesResponse",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "launch_template_specification",
         "LaunchTemplateSpecification",
 ,
-37
+    )
     .with_xml_name("launchTemplateSpecification");
 static LAUNCHTEMPLATEANDOVERRIDESRESPONSE_MEMBER_OVERRIDES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateAndOverridesResponse$Overrides",
         "com.amazonaws.ec2",
         "LaunchTemplateAndOverridesResponse",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "overrides",
     "Overrides",
 ,
-48
+)
 .with_xml_name("overrides");
 static LAUNCHTEMPLATEANDOVERRIDESRESPONSE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATEANDOVERRIDESRESPONSE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATEANDOVERRIDESRESPONSE_MEMBER_LAUNCH_TEMPLATE_SPECIFICATION,
         &LAUNCHTEMPLATEANDOVERRIDESRESPONSE_MEMBER_OVERRIDES,
     ],
 );
 impl LaunchTemplateAndOverridesResponse {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATEANDOVERRIDESRESPONSE_SCHEMA;
-61
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateAndOverridesResponse {
     #[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(&LAUNCHTEMPLATEANDOVERRIDESRESPONSE_MEMBER_LAUNCH_TEMPLATE_SPECIFICATION, val)?;
-70
+        }
         if let Some(ref val) = self.overrides {
             ser.write_struct(&LAUNCHTEMPLATEANDOVERRIDESRESPONSE_MEMBER_OVERRIDES, val)?;
-73
+        }
         Ok(())
-75
+    }
-76
+}
 impl LaunchTemplateAndOverridesResponse {
     /// 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(&LAUNCHTEMPLATEANDOVERRIDESRESPONSE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATEANDOVERRIDESRESPONSE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.launch_template_specification = Some(crate::types::FleetLaunchTemplateSpecification::deserialize(deser)?);
-95
+                }
                 Some(1) => {
                     builder.overrides = Some(crate::types::FleetLaunchTemplateOverrides::deserialize(deser)?);
-98
+                }
                 _ => {}
-100
+            }
             Ok(())
         })?;
         Ok(builder.build())
-104
+    }
-105
+}
 impl LaunchTemplateAndOverridesResponse {
     /// 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 LaunchTemplateAndOverridesResponse {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateAndOverridesResponse`](crate::types::LaunchTemplateAndOverridesResponse).
     pub fn builder() -> crate::types::builders::LaunchTemplateAndOverridesResponseBuilder {
         crate::types::builders::LaunchTemplateAndOverridesResponseBuilder::default()
-121
+    }
-122
+}
-123
 /// A builder for [`LaunchTemplateAndOverridesResponse`](crate::types::LaunchTemplateAndOverridesResponse).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateAndOverridesResponseBuilder {
     pub(crate) launch_template_specification: ::std::option::Option<crate::types::FleetLaunchTemplateSpecification>,
     pub(crate) overrides: ::std::option::Option<crate::types::FleetLaunchTemplateOverrides>,
-130
+}
 impl LaunchTemplateAndOverridesResponseBuilder {
     /// <p>The launch template.</p>
     pub fn launch_template_specification(mut self, input: crate::types::FleetLaunchTemplateSpecification) -> Self {
         self.launch_template_specification = ::std::option::Option::Some(input);
         self
-136
+    }
     /// <p>The launch template.</p>
     pub fn set_launch_template_specification(mut self, input: ::std::option::Option<crate::types::FleetLaunchTemplateSpecification>) -> Self {
         self.launch_template_specification = input;
         self
-141
+    }
     /// <p>The launch template.</p>
     pub fn get_launch_template_specification(&self) -> &::std::option::Option<crate::types::FleetLaunchTemplateSpecification> {
         &self.launch_template_specification
-145
+    }
     /// <p>Any parameters that you specify override the same parameters in the launch template.</p>

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

@@ -16,16 +182,193 @@

↥ Expand context

 impl LaunchTemplateBlockDeviceMapping {
     /// <p>The device name.</p>
     pub fn device_name(&self) -> ::std::option::Option<&str> {
         self.device_name.as_deref()
-20
+    }
     /// <p>The virtual device name (ephemeralN).</p>
     pub fn virtual_name(&self) -> ::std::option::Option<&str> {
         self.virtual_name.as_deref()
-24
+    }
     /// <p>Information about the block device for an EBS volume.</p>
     pub fn ebs(&self) -> ::std::option::Option<&crate::types::LaunchTemplateEbsBlockDevice> {
         self.ebs.as_ref()
-28
+    }
     /// <p>To omit the device from the block device mapping, specify an empty string.</p>
     pub fn no_device(&self) -> ::std::option::Option<&str> {
         self.no_device.as_deref()
-32
+    }
-33
+}
 static LAUNCHTEMPLATEBLOCKDEVICEMAPPING_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#LaunchTemplateBlockDeviceMapping",

     "com.amazonaws.ec2",
     "LaunchTemplateBlockDeviceMapping",
 );
 static LAUNCHTEMPLATEBLOCKDEVICEMAPPING_MEMBER_DEVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateBlockDeviceMapping$DeviceName",
         "com.amazonaws.ec2",
         "LaunchTemplateBlockDeviceMapping",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "device_name",
     "DeviceName",
 ,
-48
+)
 .with_xml_name("deviceName");
 static LAUNCHTEMPLATEBLOCKDEVICEMAPPING_MEMBER_VIRTUAL_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateBlockDeviceMapping$VirtualName",
         "com.amazonaws.ec2",
         "LaunchTemplateBlockDeviceMapping",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "virtual_name",
     "VirtualName",
 ,
-59
+)
 .with_xml_name("virtualName");
 static LAUNCHTEMPLATEBLOCKDEVICEMAPPING_MEMBER_EBS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateBlockDeviceMapping$Ebs",
         "com.amazonaws.ec2",
         "LaunchTemplateBlockDeviceMapping",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "ebs",
     "Ebs",
 ,
-70
+)
 .with_xml_name("ebs");
 static LAUNCHTEMPLATEBLOCKDEVICEMAPPING_MEMBER_NO_DEVICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateBlockDeviceMapping$NoDevice",
         "com.amazonaws.ec2",
         "LaunchTemplateBlockDeviceMapping",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "no_device",
     "NoDevice",
 ,
-81
+)
 .with_xml_name("noDevice");
 static LAUNCHTEMPLATEBLOCKDEVICEMAPPING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATEBLOCKDEVICEMAPPING_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATEBLOCKDEVICEMAPPING_MEMBER_DEVICE_NAME,
         &LAUNCHTEMPLATEBLOCKDEVICEMAPPING_MEMBER_VIRTUAL_NAME,
         &LAUNCHTEMPLATEBLOCKDEVICEMAPPING_MEMBER_EBS,
         &LAUNCHTEMPLATEBLOCKDEVICEMAPPING_MEMBER_NO_DEVICE,
     ],
 );
 impl LaunchTemplateBlockDeviceMapping {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATEBLOCKDEVICEMAPPING_SCHEMA;
-96
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateBlockDeviceMapping {
     #[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.device_name {
             ser.write_string(&LAUNCHTEMPLATEBLOCKDEVICEMAPPING_MEMBER_DEVICE_NAME, val)?;
-105
+        }
         if let Some(ref val) = self.virtual_name {
             ser.write_string(&LAUNCHTEMPLATEBLOCKDEVICEMAPPING_MEMBER_VIRTUAL_NAME, val)?;
-108
+        }
         if let Some(ref val) = self.ebs {
             ser.write_struct(&LAUNCHTEMPLATEBLOCKDEVICEMAPPING_MEMBER_EBS, val)?;
-111
+        }
         if let Some(ref val) = self.no_device {
             ser.write_string(&LAUNCHTEMPLATEBLOCKDEVICEMAPPING_MEMBER_NO_DEVICE, val)?;
-114
+        }
         Ok(())
-116
+    }
-117
+}
 impl LaunchTemplateBlockDeviceMapping {
     /// 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(&LAUNCHTEMPLATEBLOCKDEVICEMAPPING_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATEBLOCKDEVICEMAPPING_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.device_name = Some(deser.read_string(member)?);
-136
+                }
                 Some(1) => {
                     builder.virtual_name = Some(deser.read_string(member)?);
-139
+                }
                 Some(2) => {
                     builder.ebs = Some(crate::types::LaunchTemplateEbsBlockDevice::deserialize(deser)?);
-142
+                }
                 Some(3) => {
                     builder.no_device = Some(deser.read_string(member)?);
-145
+                }
                 _ => {}
-147
+            }
             Ok(())
         })?;
         Ok(builder.build())
-151
+    }
-152
+}
 impl LaunchTemplateBlockDeviceMapping {
     /// 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 LaunchTemplateBlockDeviceMapping {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateBlockDeviceMapping`](crate::types::LaunchTemplateBlockDeviceMapping).
     pub fn builder() -> crate::types::builders::LaunchTemplateBlockDeviceMappingBuilder {
         crate::types::builders::LaunchTemplateBlockDeviceMappingBuilder::default()
-168
+    }
-169
+}
-170
 /// A builder for [`LaunchTemplateBlockDeviceMapping`](crate::types::LaunchTemplateBlockDeviceMapping).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateBlockDeviceMappingBuilder {
     pub(crate) device_name: ::std::option::Option<::std::string::String>,
     pub(crate) virtual_name: ::std::option::Option<::std::string::String>,
     pub(crate) ebs: ::std::option::Option<crate::types::LaunchTemplateEbsBlockDevice>,
     pub(crate) no_device: ::std::option::Option<::std::string::String>,
-179
+}
 impl LaunchTemplateBlockDeviceMappingBuilder {
     /// <p>The device name.</p>
     pub fn device_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.device_name = ::std::option::Option::Some(input.into());
         self
-185
+    }
     /// <p>The device name.</p>
     pub fn set_device_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.device_name = input;
         self
-190
+    }
     /// <p>The device name.</p>
     pub fn get_device_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.device_name

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

@@ -16,16 +178,189 @@

↥ Expand context

 impl LaunchTemplateBlockDeviceMappingRequest {
     /// <p>The device name (for example, /dev/sdh or xvdh).</p>
     pub fn device_name(&self) -> ::std::option::Option<&str> {
         self.device_name.as_deref()
-20
+    }
     /// <p>The virtual device name (ephemeralN). Instance store volumes are numbered starting from 0. An instance type with 2 available instance store volumes can specify mappings for ephemeral0 and ephemeral1. The number of available instance store volumes depends on the instance type. After you connect to the instance, you must mount the volume.</p>
     pub fn virtual_name(&self) -> ::std::option::Option<&str> {
         self.virtual_name.as_deref()
-24
+    }
     /// <p>Parameters used to automatically set up EBS volumes when the instance is launched.</p>
     pub fn ebs(&self) -> ::std::option::Option<&crate::types::LaunchTemplateEbsBlockDeviceRequest> {
         self.ebs.as_ref()
-28
+    }
     /// <p>To omit the device from the block device mapping, specify an empty string.</p>
     pub fn no_device(&self) -> ::std::option::Option<&str> {
         self.no_device.as_deref()
-32
+    }
-33
+}
 static LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#LaunchTemplateBlockDeviceMappingRequest",

     "com.amazonaws.ec2",
     "LaunchTemplateBlockDeviceMappingRequest",
 );
 static LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_MEMBER_DEVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateBlockDeviceMappingRequest$DeviceName",
         "com.amazonaws.ec2",
         "LaunchTemplateBlockDeviceMappingRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "device_name",
     "DeviceName",
 ,
 );
 static LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_MEMBER_VIRTUAL_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateBlockDeviceMappingRequest$VirtualName",
         "com.amazonaws.ec2",
         "LaunchTemplateBlockDeviceMappingRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "virtual_name",
     "VirtualName",
 ,
 );
 static LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_MEMBER_EBS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateBlockDeviceMappingRequest$Ebs",
         "com.amazonaws.ec2",
         "LaunchTemplateBlockDeviceMappingRequest",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "ebs",
     "Ebs",
 ,
 );
 static LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_MEMBER_NO_DEVICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateBlockDeviceMappingRequest$NoDevice",
         "com.amazonaws.ec2",
         "LaunchTemplateBlockDeviceMappingRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "no_device",
     "NoDevice",
 ,
 );
 static LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_MEMBER_DEVICE_NAME,
         &LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_MEMBER_VIRTUAL_NAME,
         &LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_MEMBER_EBS,
         &LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_MEMBER_NO_DEVICE,
     ],
 );
 impl LaunchTemplateBlockDeviceMappingRequest {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_SCHEMA;
-92
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateBlockDeviceMappingRequest {
     #[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.device_name {
             ser.write_string(&LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_MEMBER_DEVICE_NAME, val)?;
-101
+        }
         if let Some(ref val) = self.virtual_name {
             ser.write_string(&LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_MEMBER_VIRTUAL_NAME, val)?;
-104
+        }
         if let Some(ref val) = self.ebs {
             ser.write_struct(&LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_MEMBER_EBS, val)?;
-107
+        }
         if let Some(ref val) = self.no_device {
             ser.write_string(&LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_MEMBER_NO_DEVICE, val)?;
-110
+        }
         Ok(())
-112
+    }
-113
+}
 impl LaunchTemplateBlockDeviceMappingRequest {
     /// 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(&LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATEBLOCKDEVICEMAPPINGREQUEST_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.device_name = Some(deser.read_string(member)?);
-132
+                }
                 Some(1) => {
                     builder.virtual_name = Some(deser.read_string(member)?);
-135
+                }
                 Some(2) => {
                     builder.ebs = Some(crate::types::LaunchTemplateEbsBlockDeviceRequest::deserialize(deser)?);
-138
+                }
                 Some(3) => {
                     builder.no_device = Some(deser.read_string(member)?);
-141
+                }
                 _ => {}
-143
+            }
             Ok(())
         })?;
         Ok(builder.build())
-147
+    }
-148
+}
 impl LaunchTemplateBlockDeviceMappingRequest {
     /// 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 LaunchTemplateBlockDeviceMappingRequest {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateBlockDeviceMappingRequest`](crate::types::LaunchTemplateBlockDeviceMappingRequest).
     pub fn builder() -> crate::types::builders::LaunchTemplateBlockDeviceMappingRequestBuilder {
         crate::types::builders::LaunchTemplateBlockDeviceMappingRequestBuilder::default()
-164
+    }
-165
+}
-166
 /// A builder for [`LaunchTemplateBlockDeviceMappingRequest`](crate::types::LaunchTemplateBlockDeviceMappingRequest).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateBlockDeviceMappingRequestBuilder {
     pub(crate) device_name: ::std::option::Option<::std::string::String>,
     pub(crate) virtual_name: ::std::option::Option<::std::string::String>,
     pub(crate) ebs: ::std::option::Option<crate::types::LaunchTemplateEbsBlockDeviceRequest>,
     pub(crate) no_device: ::std::option::Option<::std::string::String>,
-175
+}
 impl LaunchTemplateBlockDeviceMappingRequestBuilder {
     /// <p>The device name (for example, /dev/sdh or xvdh).</p>
     pub fn device_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.device_name = ::std::option::Option::Some(input.into());
         self
-181
+    }
     /// <p>The device name (for example, /dev/sdh or xvdh).</p>
     pub fn set_device_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.device_name = input;
         self
-186
+    }
     /// <p>The device name (for example, /dev/sdh or xvdh).</p>
     pub fn get_device_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.device_name

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

@@ -21,21 +157,168 @@

↥ Expand context

     /// <p>Indicates the instance's Capacity Reservation preferences. Possible preferences include:</p>
     /// <ul>
     /// <li>
     /// <p><code>capacity-reservations-only</code> - The instance will only run in a Capacity Reservation or Capacity Reservation group. If capacity isn't available, the instance will fail to launch.</p></li>
     /// <li>
     /// <p><code>open</code> - The instance can run in any <code>open</code> Capacity Reservation that has matching attributes (instance type, platform, Availability Zone, tenancy).</p></li>
     /// <li>
     /// <p><code>none</code> - The instance avoids running in a Capacity Reservation even if one is available. The instance runs in On-Demand capacity.</p></li>
     /// </ul>
     pub fn capacity_reservation_preference(&self) -> ::std::option::Option<&crate::types::CapacityReservationPreference> {
         self.capacity_reservation_preference.as_ref()
-32
+    }
     /// <p>Information about the target Capacity Reservation or Capacity Reservation group.</p>
     pub fn capacity_reservation_target(&self) -> ::std::option::Option<&crate::types::CapacityReservationTarget> {
         self.capacity_reservation_target.as_ref()
-36
+    }
-37
+}
 static LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#LaunchTemplateCapacityReservationSpecificationRequest",
     "com.amazonaws.ec2",

     "LaunchTemplateCapacityReservationSpecificationRequest",
 );
 static LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONREQUEST_MEMBER_CAPACITY_RESERVATION_PREFERENCE: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2#LaunchTemplateCapacityReservationSpecificationRequest$CapacityReservationPreference",
             "com.amazonaws.ec2",
             "LaunchTemplateCapacityReservationSpecificationRequest",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "capacity_reservation_preference",
         "CapacityReservationPreference",
 ,
     );
 static LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONREQUEST_MEMBER_CAPACITY_RESERVATION_TARGET: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2#LaunchTemplateCapacityReservationSpecificationRequest$CapacityReservationTarget",
             "com.amazonaws.ec2",
             "LaunchTemplateCapacityReservationSpecificationRequest",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "capacity_reservation_target",
         "CapacityReservationTarget",
 ,
     );
 static LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONREQUEST_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONREQUEST_MEMBER_CAPACITY_RESERVATION_PREFERENCE,
         &LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONREQUEST_MEMBER_CAPACITY_RESERVATION_TARGET,
     ],
 );
 impl LaunchTemplateCapacityReservationSpecificationRequest {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONREQUEST_SCHEMA;
-76
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateCapacityReservationSpecificationRequest {
     #[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_reservation_preference {
             ser.write_string(
                 &LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONREQUEST_MEMBER_CAPACITY_RESERVATION_PREFERENCE,
                 val.as_str(),
             )?;
-88
+        }
         if let Some(ref val) = self.capacity_reservation_target {
             ser.write_struct(
                 &LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONREQUEST_MEMBER_CAPACITY_RESERVATION_TARGET,
                 val,
             )?;
-94
+        }
         Ok(())
-96
+    }
-97
+}
 impl LaunchTemplateCapacityReservationSpecificationRequest {
     /// 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(&LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONREQUEST_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONREQUEST_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.capacity_reservation_preference =
                         Some(crate::types::CapacityReservationPreference::from(deser.read_string(member)?.as_str()));
-117
+                }
                 Some(1) => {
                     builder.capacity_reservation_target = Some(crate::types::CapacityReservationTarget::deserialize(deser)?);
-120
+                }
                 _ => {}
-122
+            }
             Ok(())
         })?;
         Ok(builder.build())
-126
+    }
-127
+}
 impl LaunchTemplateCapacityReservationSpecificationRequest {
     /// 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 LaunchTemplateCapacityReservationSpecificationRequest {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateCapacityReservationSpecificationRequest`](crate::types::LaunchTemplateCapacityReservationSpecificationRequest).
     pub fn builder() -> crate::types::builders::LaunchTemplateCapacityReservationSpecificationRequestBuilder {
         crate::types::builders::LaunchTemplateCapacityReservationSpecificationRequestBuilder::default()
-143
+    }
-144
+}
-145
 /// A builder for [`LaunchTemplateCapacityReservationSpecificationRequest`](crate::types::LaunchTemplateCapacityReservationSpecificationRequest).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateCapacityReservationSpecificationRequestBuilder {
     pub(crate) capacity_reservation_preference: ::std::option::Option<crate::types::CapacityReservationPreference>,
     pub(crate) capacity_reservation_target: ::std::option::Option<crate::types::CapacityReservationTarget>,
-152
+}
 impl LaunchTemplateCapacityReservationSpecificationRequestBuilder {
     /// <p>Indicates the instance's Capacity Reservation preferences. Possible preferences include:</p>
     /// <ul>
     /// <li>
     /// <p><code>capacity-reservations-only</code> - The instance will only run in a Capacity Reservation or Capacity Reservation group. If capacity isn't available, the instance will fail to launch.</p></li>
     /// <li>
     /// <p><code>open</code> - The instance can run in any <code>open</code> Capacity Reservation that has matching attributes (instance type, platform, Availability Zone, tenancy).</p></li>
     /// <li>
     /// <p><code>none</code> - The instance avoids running in a Capacity Reservation even if one is available. The instance runs in On-Demand capacity.</p></li>
     /// </ul>
     pub fn capacity_reservation_preference(mut self, input: crate::types::CapacityReservationPreference) -> Self {
         self.capacity_reservation_preference = ::std::option::Option::Some(input);
         self
-166
+    }
     /// <p>Indicates the instance's Capacity Reservation preferences. Possible preferences include:</p>
     /// <ul>

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

@@ -17,17 +155,166 @@

↥ Expand context

-17
+}
 impl LaunchTemplateCapacityReservationSpecificationResponse {
     /// <p>Indicates the instance's Capacity Reservation preferences. Possible preferences include:</p>
     /// <ul>
     /// <li>
     /// <p><code>open</code> - The instance can run in any <code>open</code> Capacity Reservation that has matching attributes (instance type, platform, Availability Zone).</p></li>
     /// <li>
     /// <p><code>none</code> - The instance avoids running in a Capacity Reservation even if one is available. The instance runs in On-Demand capacity.</p></li>
     /// </ul>
     pub fn capacity_reservation_preference(&self) -> ::std::option::Option<&crate::types::CapacityReservationPreference> {
         self.capacity_reservation_preference.as_ref()
-28
+    }
     /// <p>Information about the target Capacity Reservation or Capacity Reservation group.</p>
     pub fn capacity_reservation_target(&self) -> ::std::option::Option<&crate::types::CapacityReservationTargetResponse> {
         self.capacity_reservation_target.as_ref()
-32
+    }
-33
+}
 static LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONRESPONSE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#LaunchTemplateCapacityReservationSpecificationResponse",
     "com.amazonaws.ec2",

     "LaunchTemplateCapacityReservationSpecificationResponse",
 );
 static LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONRESPONSE_MEMBER_CAPACITY_RESERVATION_PREFERENCE: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2#LaunchTemplateCapacityReservationSpecificationResponse$CapacityReservationPreference",
             "com.amazonaws.ec2",
             "LaunchTemplateCapacityReservationSpecificationResponse",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "capacity_reservation_preference",
         "CapacityReservationPreference",
 ,
-49
+    )
     .with_xml_name("capacityReservationPreference");
 static LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONRESPONSE_MEMBER_CAPACITY_RESERVATION_TARGET: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2#LaunchTemplateCapacityReservationSpecificationResponse$CapacityReservationTarget",
             "com.amazonaws.ec2",
             "LaunchTemplateCapacityReservationSpecificationResponse",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "capacity_reservation_target",
         "CapacityReservationTarget",
 ,
-61
+    )
     .with_xml_name("capacityReservationTarget");
 static LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONRESPONSE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONRESPONSE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONRESPONSE_MEMBER_CAPACITY_RESERVATION_PREFERENCE,
         &LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONRESPONSE_MEMBER_CAPACITY_RESERVATION_TARGET,
     ],
 );
 impl LaunchTemplateCapacityReservationSpecificationResponse {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONRESPONSE_SCHEMA;
-74
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateCapacityReservationSpecificationResponse {
     #[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_reservation_preference {
             ser.write_string(
                 &LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONRESPONSE_MEMBER_CAPACITY_RESERVATION_PREFERENCE,
                 val.as_str(),
             )?;
-86
+        }
         if let Some(ref val) = self.capacity_reservation_target {
             ser.write_struct(
                 &LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONRESPONSE_MEMBER_CAPACITY_RESERVATION_TARGET,
                 val,
             )?;
-92
+        }
         Ok(())
-94
+    }
-95
+}
 impl LaunchTemplateCapacityReservationSpecificationResponse {
     /// 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(&LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONRESPONSE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATECAPACITYRESERVATIONSPECIFICATIONRESPONSE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.capacity_reservation_preference =
                         Some(crate::types::CapacityReservationPreference::from(deser.read_string(member)?.as_str()));
-115
+                }
                 Some(1) => {
                     builder.capacity_reservation_target = Some(crate::types::CapacityReservationTargetResponse::deserialize(deser)?);
-118
+                }
                 _ => {}
-120
+            }
             Ok(())
         })?;
         Ok(builder.build())
-124
+    }
-125
+}
 impl LaunchTemplateCapacityReservationSpecificationResponse {
     /// 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 LaunchTemplateCapacityReservationSpecificationResponse {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateCapacityReservationSpecificationResponse`](crate::types::LaunchTemplateCapacityReservationSpecificationResponse).
     pub fn builder() -> crate::types::builders::LaunchTemplateCapacityReservationSpecificationResponseBuilder {
         crate::types::builders::LaunchTemplateCapacityReservationSpecificationResponseBuilder::default()
-141
+    }
-142
+}
-143
 /// A builder for [`LaunchTemplateCapacityReservationSpecificationResponse`](crate::types::LaunchTemplateCapacityReservationSpecificationResponse).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateCapacityReservationSpecificationResponseBuilder {
     pub(crate) capacity_reservation_preference: ::std::option::Option<crate::types::CapacityReservationPreference>,
     pub(crate) capacity_reservation_target: ::std::option::Option<crate::types::CapacityReservationTargetResponse>,
-150
+}
 impl LaunchTemplateCapacityReservationSpecificationResponseBuilder {
     /// <p>Indicates the instance's Capacity Reservation preferences. Possible preferences include:</p>
     /// <ul>
     /// <li>
     /// <p><code>open</code> - The instance can run in any <code>open</code> Capacity Reservation that has matching attributes (instance type, platform, Availability Zone).</p></li>
     /// <li>
     /// <p><code>none</code> - The instance avoids running in a Capacity Reservation even if one is available. The instance runs in On-Demand capacity.</p></li>
     /// </ul>
     pub fn capacity_reservation_preference(mut self, input: crate::types::CapacityReservationPreference) -> Self {
         self.capacity_reservation_preference = ::std::option::Option::Some(input);
         self
-162
+    }
     /// <p>Indicates the instance's Capacity Reservation preferences. Possible preferences include:</p>
     /// <ul>
     /// <li>
     /// <p><code>open</code> - The instance can run in any <code>open</code> Capacity Reservation that has matching attributes (instance type, platform, Availability Zone).</p></li>

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

@@ -3,3 +151,159 @@

↥ Expand context

 /// <p>Describes a launch template and overrides.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct LaunchTemplateConfig {
     /// <p>The launch template to use. Make sure that the launch template does not contain the <code>NetworkInterfaceId</code> parameter because you can't specify a network interface ID in a Spot Fleet.</p>
     pub launch_template_specification: ::std::option::Option<crate::types::FleetLaunchTemplateSpecification>,
     /// <p>Any parameters that you specify override the same parameters in the launch template.</p>
     pub overrides: ::std::option::Option<::std::vec::Vec<crate::types::LaunchTemplateOverrides>>,
-11
+}
 impl LaunchTemplateConfig {
     /// <p>The launch template to use. Make sure that the launch template does not contain the <code>NetworkInterfaceId</code> parameter because you can't specify a network interface ID in a Spot Fleet.</p>
     pub fn launch_template_specification(&self) -> ::std::option::Option<&crate::types::FleetLaunchTemplateSpecification> {
         self.launch_template_specification.as_ref()
-16
+    }
     /// <p>Any parameters that you specify override the same parameters in the launch template.</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::LaunchTemplateOverrides] {
         self.overrides.as_deref().unwrap_or_default()
-22
+    }

-23
+}
 static LAUNCHTEMPLATECONFIG_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#LaunchTemplateConfig", "com.amazonaws.ec2", "LaunchTemplateConfig");
 static LAUNCHTEMPLATECONFIG_MEMBER_LAUNCH_TEMPLATE_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateConfig$LaunchTemplateSpecification",
         "com.amazonaws.ec2",
         "LaunchTemplateConfig",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "launch_template_specification",
     "LaunchTemplateSpecification",
 ,
-35
+)
 .with_xml_name("launchTemplateSpecification");
 static LAUNCHTEMPLATECONFIG_MEMBER_OVERRIDES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateConfig$Overrides",
         "com.amazonaws.ec2",
         "LaunchTemplateConfig",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "overrides",
     "Overrides",
 ,
-46
+)
 .with_xml_name("overrides");
 static LAUNCHTEMPLATECONFIG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATECONFIG_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATECONFIG_MEMBER_LAUNCH_TEMPLATE_SPECIFICATION,
         &LAUNCHTEMPLATECONFIG_MEMBER_OVERRIDES,
     ],
 );
 impl LaunchTemplateConfig {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATECONFIG_SCHEMA;
-59
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateConfig {
     #[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(&LAUNCHTEMPLATECONFIG_MEMBER_LAUNCH_TEMPLATE_SPECIFICATION, val)?;
-68
+        }
         if let Some(ref val) = self.overrides {
             ser.write_list(
                 &LAUNCHTEMPLATECONFIG_MEMBER_OVERRIDES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::LaunchTemplateOverrides::SCHEMA, item)?;
-75
+                    }
                     Ok(())
                 },
             )?;
-79
+        }
         Ok(())
-81
+    }
-82
+}
 impl LaunchTemplateConfig {
     /// 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(&LAUNCHTEMPLATECONFIG_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATECONFIG_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.launch_template_specification = Some(crate::types::FleetLaunchTemplateSpecification::deserialize(deser)?);
-101
+                }
                 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::LaunchTemplateOverrides::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::LaunchTemplateOverrides::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-111
+                }
                 _ => {}
-113
+            }
             Ok(())
         })?;
         Ok(builder.build())
-117
+    }
-118
+}
 impl LaunchTemplateConfig {
     /// 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 LaunchTemplateConfig {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateConfig`](crate::types::LaunchTemplateConfig).
     pub fn builder() -> crate::types::builders::LaunchTemplateConfigBuilder {
         crate::types::builders::LaunchTemplateConfigBuilder::default()
-134
+    }
-135
+}
-136
 /// A builder for [`LaunchTemplateConfig`](crate::types::LaunchTemplateConfig).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateConfigBuilder {
     pub(crate) launch_template_specification: ::std::option::Option<crate::types::FleetLaunchTemplateSpecification>,
     pub(crate) overrides: ::std::option::Option<::std::vec::Vec<crate::types::LaunchTemplateOverrides>>,
-143
+}
 impl LaunchTemplateConfigBuilder {
     /// <p>The launch template to use. Make sure that the launch template does not contain the <code>NetworkInterfaceId</code> parameter because you can't specify a network interface ID in a Spot Fleet.</p>
     pub fn launch_template_specification(mut self, input: crate::types::FleetLaunchTemplateSpecification) -> Self {
         self.launch_template_specification = ::std::option::Option::Some(input);
         self
-149
+    }
     /// <p>The launch template to use. Make sure that the launch template does not contain the <code>NetworkInterfaceId</code> parameter because you can't specify a network interface ID in a Spot Fleet.</p>
     pub fn set_launch_template_specification(mut self, input: ::std::option::Option<crate::types::FleetLaunchTemplateSpecification>) -> Self {
         self.launch_template_specification = input;
         self
-154
+    }
     /// <p>The launch template to use. Make sure that the launch template does not contain the <code>NetworkInterfaceId</code> parameter because you can't specify a network interface ID in a Spot Fleet.</p>
     pub fn get_launch_template_specification(&self) -> &::std::option::Option<crate::types::FleetLaunchTemplateSpecification> {
         &self.launch_template_specification
-158
+    }
     /// Appends an item to `overrides`.

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

@@ -10,10 +158,169 @@

↥ Expand context

     pub threads_per_core: ::std::option::Option<i32>,
     /// <p>Indicates whether the instance is enabled for AMD SEV-SNP. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sev-snp.html">AMD SEV-SNP for Amazon EC2 instances</a>.</p>
     pub amd_sev_snp: ::std::option::Option<crate::types::AmdSevSnpSpecification>,
-13
+}
 impl LaunchTemplateCpuOptions {
     /// <p>The number of CPU cores for the instance.</p>
     pub fn core_count(&self) -> ::std::option::Option<i32> {
         self.core_count
-18
+    }
     /// <p>The number of threads per CPU core.</p>
     pub fn threads_per_core(&self) -> ::std::option::Option<i32> {
         self.threads_per_core
-22
+    }
     /// <p>Indicates whether the instance is enabled for AMD SEV-SNP. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sev-snp.html">AMD SEV-SNP for Amazon EC2 instances</a>.</p>
     pub fn amd_sev_snp(&self) -> ::std::option::Option<&crate::types::AmdSevSnpSpecification> {
         self.amd_sev_snp.as_ref()
-26
+    }
-27
+}
 static LAUNCHTEMPLATECPUOPTIONS_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#LaunchTemplateCpuOptions",

     "com.amazonaws.ec2",
     "LaunchTemplateCpuOptions",
 );
 static LAUNCHTEMPLATECPUOPTIONS_MEMBER_CORE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateCpuOptions$CoreCount",
         "com.amazonaws.ec2",
         "LaunchTemplateCpuOptions",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "core_count",
     "CoreCount",
 ,
-42
+)
 .with_xml_name("coreCount");
 static LAUNCHTEMPLATECPUOPTIONS_MEMBER_THREADS_PER_CORE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateCpuOptions$ThreadsPerCore",
         "com.amazonaws.ec2",
         "LaunchTemplateCpuOptions",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "threads_per_core",
     "ThreadsPerCore",
 ,
-53
+)
 .with_xml_name("threadsPerCore");
 static LAUNCHTEMPLATECPUOPTIONS_MEMBER_AMD_SEV_SNP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateCpuOptions$AmdSevSnp",
         "com.amazonaws.ec2",
         "LaunchTemplateCpuOptions",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "amd_sev_snp",
     "AmdSevSnp",
 ,
-64
+)
 .with_xml_name("amdSevSnp");
 static LAUNCHTEMPLATECPUOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATECPUOPTIONS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATECPUOPTIONS_MEMBER_CORE_COUNT,
         &LAUNCHTEMPLATECPUOPTIONS_MEMBER_THREADS_PER_CORE,
         &LAUNCHTEMPLATECPUOPTIONS_MEMBER_AMD_SEV_SNP,
     ],
 );
 impl LaunchTemplateCpuOptions {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATECPUOPTIONS_SCHEMA;
-78
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateCpuOptions {
     #[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.core_count {
             ser.write_integer(&LAUNCHTEMPLATECPUOPTIONS_MEMBER_CORE_COUNT, *val)?;
-87
+        }
         if let Some(ref val) = self.threads_per_core {
             ser.write_integer(&LAUNCHTEMPLATECPUOPTIONS_MEMBER_THREADS_PER_CORE, *val)?;
-90
+        }
         if let Some(ref val) = self.amd_sev_snp {
             ser.write_string(&LAUNCHTEMPLATECPUOPTIONS_MEMBER_AMD_SEV_SNP, val.as_str())?;
-93
+        }
         Ok(())
-95
+    }
-96
+}
 impl LaunchTemplateCpuOptions {
     /// 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(&LAUNCHTEMPLATECPUOPTIONS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATECPUOPTIONS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.core_count = Some(deser.read_integer(member)?);
-115
+                }
                 Some(1) => {
                     builder.threads_per_core = Some(deser.read_integer(member)?);
-118
+                }
                 Some(2) => {
                     builder.amd_sev_snp = Some(crate::types::AmdSevSnpSpecification::from(deser.read_string(member)?.as_str()));
-121
+                }
                 _ => {}
-123
+            }
             Ok(())
         })?;
         Ok(builder.build())
-127
+    }
-128
+}
 impl LaunchTemplateCpuOptions {
     /// 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 LaunchTemplateCpuOptions {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateCpuOptions`](crate::types::LaunchTemplateCpuOptions).
     pub fn builder() -> crate::types::builders::LaunchTemplateCpuOptionsBuilder {
         crate::types::builders::LaunchTemplateCpuOptionsBuilder::default()
-144
+    }
-145
+}
-146
 /// A builder for [`LaunchTemplateCpuOptions`](crate::types::LaunchTemplateCpuOptions).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateCpuOptionsBuilder {
     pub(crate) core_count: ::std::option::Option<i32>,
     pub(crate) threads_per_core: ::std::option::Option<i32>,
     pub(crate) amd_sev_snp: ::std::option::Option<crate::types::AmdSevSnpSpecification>,
-154
+}
 impl LaunchTemplateCpuOptionsBuilder {
     /// <p>The number of CPU cores for the instance.</p>
     pub fn core_count(mut self, input: i32) -> Self {
         self.core_count = ::std::option::Option::Some(input);
         self
-160
+    }
     /// <p>The number of CPU cores for the instance.</p>
     pub fn set_core_count(mut self, input: ::std::option::Option<i32>) -> Self {
         self.core_count = input;
         self
-165
+    }
     /// <p>The number of CPU cores for the instance.</p>
     pub fn get_core_count(&self) -> &::std::option::Option<i32> {
         &self.core_count
-169
+    }

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

@@ -10,10 +155,166 @@

↥ Expand context

     pub threads_per_core: ::std::option::Option<i32>,
     /// <p>Indicates whether to enable the instance for AMD SEV-SNP. AMD SEV-SNP is supported with M6a, R6a, and C6a instance types only. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sev-snp.html">AMD SEV-SNP for Amazon EC2 instances</a>.</p>
     pub amd_sev_snp: ::std::option::Option<crate::types::AmdSevSnpSpecification>,
-13
+}
 impl LaunchTemplateCpuOptionsRequest {
     /// <p>The number of CPU cores for the instance.</p>
     pub fn core_count(&self) -> ::std::option::Option<i32> {
         self.core_count
-18
+    }
     /// <p>The number of threads per CPU core. To disable multithreading for the instance, specify a value of <code>1</code>. Otherwise, specify the default value of <code>2</code>.</p>
     pub fn threads_per_core(&self) -> ::std::option::Option<i32> {
         self.threads_per_core
-22
+    }
     /// <p>Indicates whether to enable the instance for AMD SEV-SNP. AMD SEV-SNP is supported with M6a, R6a, and C6a instance types only. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sev-snp.html">AMD SEV-SNP for Amazon EC2 instances</a>.</p>
     pub fn amd_sev_snp(&self) -> ::std::option::Option<&crate::types::AmdSevSnpSpecification> {
         self.amd_sev_snp.as_ref()
-26
+    }
-27
+}
 static LAUNCHTEMPLATECPUOPTIONSREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#LaunchTemplateCpuOptionsRequest",

     "com.amazonaws.ec2",
     "LaunchTemplateCpuOptionsRequest",
 );
 static LAUNCHTEMPLATECPUOPTIONSREQUEST_MEMBER_CORE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateCpuOptionsRequest$CoreCount",
         "com.amazonaws.ec2",
         "LaunchTemplateCpuOptionsRequest",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "core_count",
     "CoreCount",
 ,
 );
 static LAUNCHTEMPLATECPUOPTIONSREQUEST_MEMBER_THREADS_PER_CORE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateCpuOptionsRequest$ThreadsPerCore",
         "com.amazonaws.ec2",
         "LaunchTemplateCpuOptionsRequest",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "threads_per_core",
     "ThreadsPerCore",
 ,
 );
 static LAUNCHTEMPLATECPUOPTIONSREQUEST_MEMBER_AMD_SEV_SNP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateCpuOptionsRequest$AmdSevSnp",
         "com.amazonaws.ec2",
         "LaunchTemplateCpuOptionsRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "amd_sev_snp",
     "AmdSevSnp",
 ,
 );
 static LAUNCHTEMPLATECPUOPTIONSREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATECPUOPTIONSREQUEST_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATECPUOPTIONSREQUEST_MEMBER_CORE_COUNT,
         &LAUNCHTEMPLATECPUOPTIONSREQUEST_MEMBER_THREADS_PER_CORE,
         &LAUNCHTEMPLATECPUOPTIONSREQUEST_MEMBER_AMD_SEV_SNP,
     ],
 );
 impl LaunchTemplateCpuOptionsRequest {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATECPUOPTIONSREQUEST_SCHEMA;
-75
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateCpuOptionsRequest {
     #[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.core_count {
             ser.write_integer(&LAUNCHTEMPLATECPUOPTIONSREQUEST_MEMBER_CORE_COUNT, *val)?;
-84
+        }
         if let Some(ref val) = self.threads_per_core {
             ser.write_integer(&LAUNCHTEMPLATECPUOPTIONSREQUEST_MEMBER_THREADS_PER_CORE, *val)?;
-87
+        }
         if let Some(ref val) = self.amd_sev_snp {
             ser.write_string(&LAUNCHTEMPLATECPUOPTIONSREQUEST_MEMBER_AMD_SEV_SNP, val.as_str())?;
-90
+        }
         Ok(())
-92
+    }
-93
+}
 impl LaunchTemplateCpuOptionsRequest {
     /// 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(&LAUNCHTEMPLATECPUOPTIONSREQUEST_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATECPUOPTIONSREQUEST_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.core_count = Some(deser.read_integer(member)?);
-112
+                }
                 Some(1) => {
                     builder.threads_per_core = Some(deser.read_integer(member)?);
-115
+                }
                 Some(2) => {
                     builder.amd_sev_snp = Some(crate::types::AmdSevSnpSpecification::from(deser.read_string(member)?.as_str()));
-118
+                }
                 _ => {}
-120
+            }
             Ok(())
         })?;
         Ok(builder.build())
-124
+    }
-125
+}
 impl LaunchTemplateCpuOptionsRequest {
     /// 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 LaunchTemplateCpuOptionsRequest {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateCpuOptionsRequest`](crate::types::LaunchTemplateCpuOptionsRequest).
     pub fn builder() -> crate::types::builders::LaunchTemplateCpuOptionsRequestBuilder {
         crate::types::builders::LaunchTemplateCpuOptionsRequestBuilder::default()
-141
+    }
-142
+}
-143
 /// A builder for [`LaunchTemplateCpuOptionsRequest`](crate::types::LaunchTemplateCpuOptionsRequest).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateCpuOptionsRequestBuilder {
     pub(crate) core_count: ::std::option::Option<i32>,
     pub(crate) threads_per_core: ::std::option::Option<i32>,
     pub(crate) amd_sev_snp: ::std::option::Option<crate::types::AmdSevSnpSpecification>,
-151
+}
 impl LaunchTemplateCpuOptionsRequestBuilder {
     /// <p>The number of CPU cores for the instance.</p>
     pub fn core_count(mut self, input: i32) -> Self {
         self.core_count = ::std::option::Option::Some(input);
         self
-157
+    }
     /// <p>The number of CPU cores for the instance.</p>
     pub fn set_core_count(mut self, input: ::std::option::Option<i32>) -> Self {
         self.core_count = input;
         self
-162
+    }
     /// <p>The number of CPU cores for the instance.</p>
     pub fn get_core_count(&self) -> &::std::option::Option<i32> {
         &self.core_count
-166
+    }

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

@@ -46,46 +302,313 @@

↥ Expand context

-46
+    }
     /// <p>The size of the volume, in GiB.</p>
     pub fn volume_size(&self) -> ::std::option::Option<i32> {
         self.volume_size
-50
+    }
     /// <p>The volume type.</p>
     pub fn volume_type(&self) -> ::std::option::Option<&crate::types::VolumeType> {
         self.volume_type.as_ref()
-54
+    }
     /// <p>The throughput that the volume supports, in MiB/s.</p>
     pub fn throughput(&self) -> ::std::option::Option<i32> {
         self.throughput
-58
+    }
     /// <p>The Amazon EBS Provisioned Rate for Volume Initialization (volume initialization rate) specified for the volume, in MiB/s. If no volume initialization rate was specified, the value is <code>null</code>.</p>
     pub fn volume_initialization_rate(&self) -> ::std::option::Option<i32> {
         self.volume_initialization_rate
-62
+    }
-63
+}
 static LAUNCHTEMPLATEEBSBLOCKDEVICE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#LaunchTemplateEbsBlockDevice",

     "com.amazonaws.ec2",
     "LaunchTemplateEbsBlockDevice",
 );
 static LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDevice$Encrypted",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDevice",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "encrypted",
     "Encrypted",
 ,
-78
+)
 .with_xml_name("encrypted");
 static LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_DELETE_ON_TERMINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDevice$DeleteOnTermination",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDevice",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "delete_on_termination",
     "DeleteOnTermination",
 ,
-89
+)
 .with_xml_name("deleteOnTermination");
 static LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_IOPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDevice$Iops",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDevice",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "iops",
     "Iops",
 ,
-100
+)
 .with_xml_name("iops");
 static LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDevice$KmsKeyId",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDevice",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "kms_key_id",
     "KmsKeyId",
 ,
-111
+)
 .with_xml_name("kmsKeyId");
 static LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDevice$SnapshotId",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDevice",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "snapshot_id",
     "SnapshotId",
 ,
-122
+)
 .with_xml_name("snapshotId");
 static LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_VOLUME_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDevice$VolumeSize",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDevice",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "volume_size",
     "VolumeSize",
 ,
-133
+)
 .with_xml_name("volumeSize");
 static LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_VOLUME_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDevice$VolumeType",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDevice",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "volume_type",
     "VolumeType",
 ,
-144
+)
 .with_xml_name("volumeType");
 static LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDevice$Throughput",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDevice",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "throughput",
     "Throughput",
 ,
-155
+)
 .with_xml_name("throughput");
 static LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_VOLUME_INITIALIZATION_RATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDevice$VolumeInitializationRate",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDevice",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "volume_initialization_rate",
     "VolumeInitializationRate",
 ,
-166
+)
 .with_xml_name("volumeInitializationRate");
 static LAUNCHTEMPLATEEBSBLOCKDEVICE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATEEBSBLOCKDEVICE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_ENCRYPTED,
         &LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_DELETE_ON_TERMINATION,
         &LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_IOPS,
         &LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_KMS_KEY_ID,
         &LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_SNAPSHOT_ID,
         &LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_VOLUME_SIZE,
         &LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_VOLUME_TYPE,
         &LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_THROUGHPUT,
         &LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_VOLUME_INITIALIZATION_RATE,
     ],
 );
 impl LaunchTemplateEbsBlockDevice {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATEEBSBLOCKDEVICE_SCHEMA;
-186
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateEbsBlockDevice {
     #[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.encrypted {
             ser.write_boolean(&LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_ENCRYPTED, *val)?;
-195
+        }
         if let Some(ref val) = self.delete_on_termination {
             ser.write_boolean(&LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_DELETE_ON_TERMINATION, *val)?;
-198
+        }
         if let Some(ref val) = self.iops {
             ser.write_integer(&LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_IOPS, *val)?;
-201
+        }
         if let Some(ref val) = self.kms_key_id {
             ser.write_string(&LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_KMS_KEY_ID, val)?;
-204
+        }
         if let Some(ref val) = self.snapshot_id {
             ser.write_string(&LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_SNAPSHOT_ID, val)?;
-207
+        }
         if let Some(ref val) = self.volume_size {
             ser.write_integer(&LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_VOLUME_SIZE, *val)?;
-210
+        }
         if let Some(ref val) = self.volume_type {
             ser.write_string(&LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_VOLUME_TYPE, val.as_str())?;
-213
+        }
         if let Some(ref val) = self.throughput {
             ser.write_integer(&LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_THROUGHPUT, *val)?;
-216
+        }
         if let Some(ref val) = self.volume_initialization_rate {
             ser.write_integer(&LAUNCHTEMPLATEEBSBLOCKDEVICE_MEMBER_VOLUME_INITIALIZATION_RATE, *val)?;
-219
+        }
         Ok(())
-221
+    }
-222
+}
 impl LaunchTemplateEbsBlockDevice {
     /// 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(&LAUNCHTEMPLATEEBSBLOCKDEVICE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATEEBSBLOCKDEVICE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.encrypted = Some(deser.read_boolean(member)?);
-241
+                }
                 Some(1) => {
                     builder.delete_on_termination = Some(deser.read_boolean(member)?);
-244
+                }
                 Some(2) => {
                     builder.iops = Some(deser.read_integer(member)?);
-247
+                }
                 Some(3) => {
                     builder.kms_key_id = Some(deser.read_string(member)?);
-250
+                }
                 Some(4) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-253
+                }
                 Some(5) => {
                     builder.volume_size = Some(deser.read_integer(member)?);
-256
+                }
                 Some(6) => {
                     builder.volume_type = Some(crate::types::VolumeType::from(deser.read_string(member)?.as_str()));
-259
+                }
                 Some(7) => {
                     builder.throughput = Some(deser.read_integer(member)?);
-262
+                }
                 Some(8) => {
                     builder.volume_initialization_rate = Some(deser.read_integer(member)?);
-265
+                }
                 _ => {}
-267
+            }
             Ok(())
         })?;
         Ok(builder.build())
-271
+    }
-272
+}
 impl LaunchTemplateEbsBlockDevice {
     /// 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 LaunchTemplateEbsBlockDevice {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateEbsBlockDevice`](crate::types::LaunchTemplateEbsBlockDevice).
     pub fn builder() -> crate::types::builders::LaunchTemplateEbsBlockDeviceBuilder {
         crate::types::builders::LaunchTemplateEbsBlockDeviceBuilder::default()
-288
+    }
-289
+}
-290
 /// A builder for [`LaunchTemplateEbsBlockDevice`](crate::types::LaunchTemplateEbsBlockDevice).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateEbsBlockDeviceBuilder {
     pub(crate) encrypted: ::std::option::Option<bool>,
     pub(crate) delete_on_termination: ::std::option::Option<bool>,
     pub(crate) iops: ::std::option::Option<i32>,
     pub(crate) kms_key_id: ::std::option::Option<::std::string::String>,
     pub(crate) snapshot_id: ::std::option::Option<::std::string::String>,
     pub(crate) volume_size: ::std::option::Option<i32>,
     pub(crate) volume_type: ::std::option::Option<crate::types::VolumeType>,
     pub(crate) throughput: ::std::option::Option<i32>,
     pub(crate) volume_initialization_rate: ::std::option::Option<i32>,
-304
+}
 impl LaunchTemplateEbsBlockDeviceBuilder {
     /// <p>Indicates whether the EBS volume is encrypted.</p>
     pub fn encrypted(mut self, input: bool) -> Self {
         self.encrypted = ::std::option::Option::Some(input);
         self
-310
+    }
     /// <p>Indicates whether the EBS volume is encrypted.</p>
     pub fn set_encrypted(mut self, input: ::std::option::Option<bool>) -> Self {
         self.encrypted = input;

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

@@ -120,120 +367,378 @@

↥ Expand context

         self.throughput
-121
+    }
     /// <p>Specifies the Amazon EBS Provisioned Rate for Volume Initialization (volume initialization rate), in MiB/s, at which to download the snapshot blocks from Amazon S3 to the volume. This is also known as <i>volume initialization</i>. Specifying a volume initialization rate ensures that the volume is initialized at a predictable and consistent rate after creation.</p>
     /// <p>This parameter is supported only for volumes created from snapshots. Omit this parameter if:</p>
     /// <ul>
     /// <li>
     /// <p>You want to create the volume using fast snapshot restore. You must specify a snapshot that is enabled for fast snapshot restore. In this case, the volume is fully initialized at creation.</p><note>
     /// <p>If you specify a snapshot that is enabled for fast snapshot restore and a volume initialization rate, the volume will be initialized at the specified rate instead of fast snapshot restore.</p>
     /// </note></li>
     /// <li>
     /// <p>You want to create a volume that is initialized at the default rate.</p></li>
     /// </ul>
     /// <p>For more information, see <a href="https://docs.aws.amazon.com/ebs/latest/userguide/initalize-volume.html"> Initialize Amazon EBS volumes</a> in the <i>Amazon EC2 User Guide</i>.</p>
     /// <p>Valid range: 100 - 300 MiB/s</p>
     pub fn volume_initialization_rate(&self) -> ::std::option::Option<i32> {
         self.volume_initialization_rate
-136
+    }
-137
+}
 static LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#LaunchTemplateEbsBlockDeviceRequest",

     "com.amazonaws.ec2",
     "LaunchTemplateEbsBlockDeviceRequest",
 );
 static LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDeviceRequest$Encrypted",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDeviceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "encrypted",
     "Encrypted",
 ,
 );
 static LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_DELETE_ON_TERMINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDeviceRequest$DeleteOnTermination",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDeviceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "delete_on_termination",
     "DeleteOnTermination",
 ,
 );
 static LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_IOPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDeviceRequest$Iops",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDeviceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "iops",
     "Iops",
 ,
 );
 static LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDeviceRequest$KmsKeyId",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDeviceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "kms_key_id",
     "KmsKeyId",
 ,
 );
 static LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDeviceRequest$SnapshotId",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDeviceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "snapshot_id",
     "SnapshotId",
 ,
 );
 static LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDeviceRequest$VolumeSize",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDeviceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "volume_size",
     "VolumeSize",
 ,
 );
 static LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDeviceRequest$VolumeType",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDeviceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "volume_type",
     "VolumeType",
 ,
 );
 static LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDeviceRequest$Throughput",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDeviceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "throughput",
     "Throughput",
 ,
 );
 static LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_INITIALIZATION_RATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEbsBlockDeviceRequest$VolumeInitializationRate",
         "com.amazonaws.ec2",
         "LaunchTemplateEbsBlockDeviceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "volume_initialization_rate",
     "VolumeInitializationRate",
 ,
 );
 static LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_ENCRYPTED,
         &LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_DELETE_ON_TERMINATION,
         &LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_IOPS,
         &LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_KMS_KEY_ID,
         &LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_SNAPSHOT_ID,
         &LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_SIZE,
         &LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_TYPE,
         &LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_THROUGHPUT,
         &LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_INITIALIZATION_RATE,
     ],
 );
 impl LaunchTemplateEbsBlockDeviceRequest {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_SCHEMA;
-251
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateEbsBlockDeviceRequest {
     #[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.encrypted {
             ser.write_boolean(&LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_ENCRYPTED, *val)?;
-260
+        }
         if let Some(ref val) = self.delete_on_termination {
             ser.write_boolean(&LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_DELETE_ON_TERMINATION, *val)?;
-263
+        }
         if let Some(ref val) = self.iops {
             ser.write_integer(&LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_IOPS, *val)?;
-266
+        }
         if let Some(ref val) = self.kms_key_id {
             ser.write_string(&LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_KMS_KEY_ID, val)?;
-269
+        }
         if let Some(ref val) = self.snapshot_id {
             ser.write_string(&LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_SNAPSHOT_ID, val)?;
-272
+        }
         if let Some(ref val) = self.volume_size {
             ser.write_integer(&LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_SIZE, *val)?;
-275
+        }
         if let Some(ref val) = self.volume_type {
             ser.write_string(&LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_TYPE, val.as_str())?;
-278
+        }
         if let Some(ref val) = self.throughput {
             ser.write_integer(&LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_THROUGHPUT, *val)?;
-281
+        }
         if let Some(ref val) = self.volume_initialization_rate {
             ser.write_integer(&LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_INITIALIZATION_RATE, *val)?;
-284
+        }
         Ok(())
-286
+    }
-287
+}
 impl LaunchTemplateEbsBlockDeviceRequest {
     /// 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(&LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATEEBSBLOCKDEVICEREQUEST_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.encrypted = Some(deser.read_boolean(member)?);
-306
+                }
                 Some(1) => {
                     builder.delete_on_termination = Some(deser.read_boolean(member)?);
-309
+                }
                 Some(2) => {
                     builder.iops = Some(deser.read_integer(member)?);
-312
+                }
                 Some(3) => {
                     builder.kms_key_id = Some(deser.read_string(member)?);
-315
+                }
                 Some(4) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-318
+                }
                 Some(5) => {
                     builder.volume_size = Some(deser.read_integer(member)?);
-321
+                }
                 Some(6) => {
                     builder.volume_type = Some(crate::types::VolumeType::from(deser.read_string(member)?.as_str()));
-324
+                }
                 Some(7) => {
                     builder.throughput = Some(deser.read_integer(member)?);
-327
+                }
                 Some(8) => {
                     builder.volume_initialization_rate = Some(deser.read_integer(member)?);
-330
+                }
                 _ => {}
-332
+            }
             Ok(())
         })?;
         Ok(builder.build())
-336
+    }
-337
+}
 impl LaunchTemplateEbsBlockDeviceRequest {
     /// 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 LaunchTemplateEbsBlockDeviceRequest {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateEbsBlockDeviceRequest`](crate::types::LaunchTemplateEbsBlockDeviceRequest).
     pub fn builder() -> crate::types::builders::LaunchTemplateEbsBlockDeviceRequestBuilder {
         crate::types::builders::LaunchTemplateEbsBlockDeviceRequestBuilder::default()
-353
+    }
-354
+}
-355
 /// A builder for [`LaunchTemplateEbsBlockDeviceRequest`](crate::types::LaunchTemplateEbsBlockDeviceRequest).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateEbsBlockDeviceRequestBuilder {
     pub(crate) encrypted: ::std::option::Option<bool>,
     pub(crate) delete_on_termination: ::std::option::Option<bool>,
     pub(crate) iops: ::std::option::Option<i32>,
     pub(crate) kms_key_id: ::std::option::Option<::std::string::String>,
     pub(crate) snapshot_id: ::std::option::Option<::std::string::String>,
     pub(crate) volume_size: ::std::option::Option<i32>,
     pub(crate) volume_type: ::std::option::Option<crate::types::VolumeType>,
     pub(crate) throughput: ::std::option::Option<i32>,
     pub(crate) volume_initialization_rate: ::std::option::Option<i32>,
-369
+}
 impl LaunchTemplateEbsBlockDeviceRequestBuilder {
     /// <p>Indicates whether the EBS volume is encrypted. Encrypted volumes can only be attached to instances that support Amazon EBS encryption. If you are creating a volume from a snapshot, you can't specify an encryption value.</p>
     pub fn encrypted(mut self, input: bool) -> Self {
         self.encrypted = ::std::option::Option::Some(input);
         self
-375
+    }
     /// <p>Indicates whether the EBS volume is encrypted. Encrypted volumes can only be attached to instances that support Amazon EBS encryption. If you are creating a volume from a snapshot, you can't specify an encryption value.</p>
     pub fn set_encrypted(mut self, input: ::std::option::Option<bool>) -> Self {
         self.encrypted = input;

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

@@ -7,7 +135,146 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct LaunchTemplateElasticInferenceAccelerator {
     /// <p>The type of elastic inference accelerator. The possible values are eia1.medium, eia1.large, and eia1.xlarge.</p>
     pub r#type: ::std::option::Option<::std::string::String>,
     /// <p>The number of elastic inference accelerators to attach to the instance.</p>
     pub count: ::std::option::Option<i32>,
-14
+}
 impl LaunchTemplateElasticInferenceAccelerator {
     /// <p>The type of elastic inference accelerator. The possible values are eia1.medium, eia1.large, and eia1.xlarge.</p>
     pub fn r#type(&self) -> ::std::option::Option<&str> {
         self.r#type.as_deref()
-19
+    }
     /// <p>The number of elastic inference accelerators to attach to the instance.</p>
     pub fn count(&self) -> ::std::option::Option<i32> {
         self.count
-23
+    }
-24
+}
 static LAUNCHTEMPLATEELASTICINFERENCEACCELERATOR_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#LaunchTemplateElasticInferenceAccelerator",

     "com.amazonaws.ec2",
     "LaunchTemplateElasticInferenceAccelerator",
 );
 static LAUNCHTEMPLATEELASTICINFERENCEACCELERATOR_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateElasticInferenceAccelerator$Type",
         "com.amazonaws.ec2",
         "LaunchTemplateElasticInferenceAccelerator",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "r##type",
     "Type",
 ,
 );
 static LAUNCHTEMPLATEELASTICINFERENCEACCELERATOR_MEMBER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateElasticInferenceAccelerator$Count",
         "com.amazonaws.ec2",
         "LaunchTemplateElasticInferenceAccelerator",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "count",
     "Count",
 ,
 );
 static LAUNCHTEMPLATEELASTICINFERENCEACCELERATOR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATEELASTICINFERENCEACCELERATOR_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATEELASTICINFERENCEACCELERATOR_MEMBER_TYPE,
         &LAUNCHTEMPLATEELASTICINFERENCEACCELERATOR_MEMBER_COUNT,
     ],
 );
 impl LaunchTemplateElasticInferenceAccelerator {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATEELASTICINFERENCEACCELERATOR_SCHEMA;
-61
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateElasticInferenceAccelerator {
     #[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.r#type {
             ser.write_string(&LAUNCHTEMPLATEELASTICINFERENCEACCELERATOR_MEMBER_TYPE, val)?;
-70
+        }
         if let Some(ref val) = self.count {
             ser.write_integer(&LAUNCHTEMPLATEELASTICINFERENCEACCELERATOR_MEMBER_COUNT, *val)?;
-73
+        }
         Ok(())
-75
+    }
-76
+}
 impl LaunchTemplateElasticInferenceAccelerator {
     /// 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(&LAUNCHTEMPLATEELASTICINFERENCEACCELERATOR_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATEELASTICINFERENCEACCELERATOR_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.r#type = Some(deser.read_string(member)?);
-95
+                }
                 Some(1) => {
                     builder.count = Some(deser.read_integer(member)?);
-98
+                }
                 _ => {}
-100
+            }
             Ok(())
         })?;
         Ok(builder.build())
-104
+    }
-105
+}
 impl LaunchTemplateElasticInferenceAccelerator {
     /// 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 LaunchTemplateElasticInferenceAccelerator {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateElasticInferenceAccelerator`](crate::types::LaunchTemplateElasticInferenceAccelerator).
     pub fn builder() -> crate::types::builders::LaunchTemplateElasticInferenceAcceleratorBuilder {
         crate::types::builders::LaunchTemplateElasticInferenceAcceleratorBuilder::default()
-121
+    }
-122
+}
-123
 /// A builder for [`LaunchTemplateElasticInferenceAccelerator`](crate::types::LaunchTemplateElasticInferenceAccelerator).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateElasticInferenceAcceleratorBuilder {
     pub(crate) r#type: ::std::option::Option<::std::string::String>,
     pub(crate) count: ::std::option::Option<i32>,
-130
+}
 impl LaunchTemplateElasticInferenceAcceleratorBuilder {
     /// <p>The type of elastic inference accelerator. The possible values are eia1.medium, eia1.large, and eia1.xlarge.</p>
     /// This field is required.
     pub fn r#type(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.r#type = ::std::option::Option::Some(input.into());
         self
-137
+    }
     /// <p>The type of elastic inference accelerator. The possible values are eia1.medium, eia1.large, and eia1.xlarge.</p>
     pub fn set_type(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.r#type = input;
         self
-142
+    }
     /// <p>The type of elastic inference accelerator. The possible values are eia1.medium, eia1.large, and eia1.xlarge.</p>
     pub fn get_type(&self) -> &::std::option::Option<::std::string::String> {
         &self.r#type
-146
+    }

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

@@ -7,7 +137,148 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct LaunchTemplateElasticInferenceAcceleratorResponse {
     /// <p>The type of elastic inference accelerator. The possible values are eia1.medium, eia1.large, and eia1.xlarge.</p>
     pub r#type: ::std::option::Option<::std::string::String>,
     /// <p>The number of elastic inference accelerators to attach to the instance.</p>
     pub count: ::std::option::Option<i32>,
-14
+}
 impl LaunchTemplateElasticInferenceAcceleratorResponse {
     /// <p>The type of elastic inference accelerator. The possible values are eia1.medium, eia1.large, and eia1.xlarge.</p>
     pub fn r#type(&self) -> ::std::option::Option<&str> {
         self.r#type.as_deref()
-19
+    }
     /// <p>The number of elastic inference accelerators to attach to the instance.</p>
     pub fn count(&self) -> ::std::option::Option<i32> {
         self.count
-23
+    }
-24
+}
 static LAUNCHTEMPLATEELASTICINFERENCEACCELERATORRESPONSE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#LaunchTemplateElasticInferenceAcceleratorResponse",

     "com.amazonaws.ec2",
     "LaunchTemplateElasticInferenceAcceleratorResponse",
 );
 static LAUNCHTEMPLATEELASTICINFERENCEACCELERATORRESPONSE_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateElasticInferenceAcceleratorResponse$Type",
         "com.amazonaws.ec2",
         "LaunchTemplateElasticInferenceAcceleratorResponse",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "r##type",
     "Type",
 ,
-39
+)
 .with_xml_name("type");
 static LAUNCHTEMPLATEELASTICINFERENCEACCELERATORRESPONSE_MEMBER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateElasticInferenceAcceleratorResponse$Count",
         "com.amazonaws.ec2",
         "LaunchTemplateElasticInferenceAcceleratorResponse",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "count",
     "Count",
 ,
-50
+)
 .with_xml_name("count");
 static LAUNCHTEMPLATEELASTICINFERENCEACCELERATORRESPONSE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATEELASTICINFERENCEACCELERATORRESPONSE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATEELASTICINFERENCEACCELERATORRESPONSE_MEMBER_TYPE,
         &LAUNCHTEMPLATEELASTICINFERENCEACCELERATORRESPONSE_MEMBER_COUNT,
     ],
 );
 impl LaunchTemplateElasticInferenceAcceleratorResponse {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATEELASTICINFERENCEACCELERATORRESPONSE_SCHEMA;
-63
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateElasticInferenceAcceleratorResponse {
     #[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.r#type {
             ser.write_string(&LAUNCHTEMPLATEELASTICINFERENCEACCELERATORRESPONSE_MEMBER_TYPE, val)?;
-72
+        }
         if let Some(ref val) = self.count {
             ser.write_integer(&LAUNCHTEMPLATEELASTICINFERENCEACCELERATORRESPONSE_MEMBER_COUNT, *val)?;
-75
+        }
         Ok(())
-77
+    }
-78
+}
 impl LaunchTemplateElasticInferenceAcceleratorResponse {
     /// 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(&LAUNCHTEMPLATEELASTICINFERENCEACCELERATORRESPONSE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATEELASTICINFERENCEACCELERATORRESPONSE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.r#type = Some(deser.read_string(member)?);
-97
+                }
                 Some(1) => {
                     builder.count = Some(deser.read_integer(member)?);
-100
+                }
                 _ => {}
-102
+            }
             Ok(())
         })?;
         Ok(builder.build())
-106
+    }
-107
+}
 impl LaunchTemplateElasticInferenceAcceleratorResponse {
     /// 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 LaunchTemplateElasticInferenceAcceleratorResponse {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateElasticInferenceAcceleratorResponse`](crate::types::LaunchTemplateElasticInferenceAcceleratorResponse).
     pub fn builder() -> crate::types::builders::LaunchTemplateElasticInferenceAcceleratorResponseBuilder {
         crate::types::builders::LaunchTemplateElasticInferenceAcceleratorResponseBuilder::default()
-123
+    }
-124
+}
-125
 /// A builder for [`LaunchTemplateElasticInferenceAcceleratorResponse`](crate::types::LaunchTemplateElasticInferenceAcceleratorResponse).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateElasticInferenceAcceleratorResponseBuilder {
     pub(crate) r#type: ::std::option::Option<::std::string::String>,
     pub(crate) count: ::std::option::Option<i32>,
-132
+}
 impl LaunchTemplateElasticInferenceAcceleratorResponseBuilder {
     /// <p>The type of elastic inference accelerator. The possible values are eia1.medium, eia1.large, and eia1.xlarge.</p>
     pub fn r#type(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.r#type = ::std::option::Option::Some(input.into());
         self
-138
+    }
     /// <p>The type of elastic inference accelerator. The possible values are eia1.medium, eia1.large, and eia1.xlarge.</p>
     pub fn set_type(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.r#type = input;
         self
-143
+    }
     /// <p>The type of elastic inference accelerator. The possible values are eia1.medium, eia1.large, and eia1.xlarge.</p>
     pub fn get_type(&self) -> &::std::option::Option<::std::string::String> {
         &self.r#type
-147
+    }
     /// <p>The number of elastic inference accelerators to attach to the instance.</p>

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

@@ -5,5 +135,146 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct LaunchTemplateEnaSrdSpecification {
     /// <p>Indicates whether ENA Express is enabled for the network interface.</p>
     pub ena_srd_enabled: ::std::option::Option<bool>,
     /// <p>Configures ENA Express for UDP network traffic.</p>
     pub ena_srd_udp_specification: ::std::option::Option<crate::types::LaunchTemplateEnaSrdUdpSpecification>,
-12
+}
 impl LaunchTemplateEnaSrdSpecification {
     /// <p>Indicates whether ENA Express is enabled for the network interface.</p>
     pub fn ena_srd_enabled(&self) -> ::std::option::Option<bool> {
         self.ena_srd_enabled
-17
+    }
     /// <p>Configures ENA Express for UDP network traffic.</p>
     pub fn ena_srd_udp_specification(&self) -> ::std::option::Option<&crate::types::LaunchTemplateEnaSrdUdpSpecification> {
         self.ena_srd_udp_specification.as_ref()
-21
+    }
-22
+}
 static LAUNCHTEMPLATEENASRDSPECIFICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#LaunchTemplateEnaSrdSpecification",

     "com.amazonaws.ec2",
     "LaunchTemplateEnaSrdSpecification",
 );
 static LAUNCHTEMPLATEENASRDSPECIFICATION_MEMBER_ENA_SRD_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEnaSrdSpecification$EnaSrdEnabled",
         "com.amazonaws.ec2",
         "LaunchTemplateEnaSrdSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "ena_srd_enabled",
     "EnaSrdEnabled",
 ,
-37
+)
 .with_xml_name("enaSrdEnabled");
 static LAUNCHTEMPLATEENASRDSPECIFICATION_MEMBER_ENA_SRD_UDP_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEnaSrdSpecification$EnaSrdUdpSpecification",
         "com.amazonaws.ec2",
         "LaunchTemplateEnaSrdSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "ena_srd_udp_specification",
     "EnaSrdUdpSpecification",
 ,
-48
+)
 .with_xml_name("enaSrdUdpSpecification");
 static LAUNCHTEMPLATEENASRDSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATEENASRDSPECIFICATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LAUNCHTEMPLATEENASRDSPECIFICATION_MEMBER_ENA_SRD_ENABLED,
         &LAUNCHTEMPLATEENASRDSPECIFICATION_MEMBER_ENA_SRD_UDP_SPECIFICATION,
     ],
 );
 impl LaunchTemplateEnaSrdSpecification {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATEENASRDSPECIFICATION_SCHEMA;
-61
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateEnaSrdSpecification {
     #[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.ena_srd_enabled {
             ser.write_boolean(&LAUNCHTEMPLATEENASRDSPECIFICATION_MEMBER_ENA_SRD_ENABLED, *val)?;
-70
+        }
         if let Some(ref val) = self.ena_srd_udp_specification {
             ser.write_struct(&LAUNCHTEMPLATEENASRDSPECIFICATION_MEMBER_ENA_SRD_UDP_SPECIFICATION, val)?;
-73
+        }
         Ok(())
-75
+    }
-76
+}
 impl LaunchTemplateEnaSrdSpecification {
     /// 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(&LAUNCHTEMPLATEENASRDSPECIFICATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATEENASRDSPECIFICATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.ena_srd_enabled = Some(deser.read_boolean(member)?);
-95
+                }
                 Some(1) => {
                     builder.ena_srd_udp_specification = Some(crate::types::LaunchTemplateEnaSrdUdpSpecification::deserialize(deser)?);
-98
+                }
                 _ => {}
-100
+            }
             Ok(())
         })?;
         Ok(builder.build())
-104
+    }
-105
+}
 impl LaunchTemplateEnaSrdSpecification {
     /// 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 LaunchTemplateEnaSrdSpecification {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateEnaSrdSpecification`](crate::types::LaunchTemplateEnaSrdSpecification).
     pub fn builder() -> crate::types::builders::LaunchTemplateEnaSrdSpecificationBuilder {
         crate::types::builders::LaunchTemplateEnaSrdSpecificationBuilder::default()
-121
+    }
-122
+}
-123
 /// A builder for [`LaunchTemplateEnaSrdSpecification`](crate::types::LaunchTemplateEnaSrdSpecification).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateEnaSrdSpecificationBuilder {
     pub(crate) ena_srd_enabled: ::std::option::Option<bool>,
     pub(crate) ena_srd_udp_specification: ::std::option::Option<crate::types::LaunchTemplateEnaSrdUdpSpecification>,
-130
+}
 impl LaunchTemplateEnaSrdSpecificationBuilder {
     /// <p>Indicates whether ENA Express is enabled for the network interface.</p>
     pub fn ena_srd_enabled(mut self, input: bool) -> Self {
         self.ena_srd_enabled = ::std::option::Option::Some(input);
         self
-136
+    }
     /// <p>Indicates whether ENA Express is enabled for the network interface.</p>
     pub fn set_ena_srd_enabled(mut self, input: ::std::option::Option<bool>) -> Self {
         self.ena_srd_enabled = input;
         self
-141
+    }
     /// <p>Indicates whether ENA Express is enabled for the network interface.</p>
     pub fn get_ena_srd_enabled(&self) -> &::std::option::Option<bool> {
         &self.ena_srd_enabled
-145
+    }
     /// <p>Configures ENA Express for UDP network traffic.</p>

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

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>ENA Express is compatible with both TCP and UDP transport protocols. When it's enabled, TCP traffic automatically uses it. However, some UDP-based applications are designed to handle network packets that are out of order, without a need for retransmission, such as live video broadcasting or other near-real-time applications. For UDP traffic, you can specify whether to use ENA Express, based on your application environment needs.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct LaunchTemplateEnaSrdUdpSpecification {
     /// <p>Indicates whether UDP traffic to and from the instance uses ENA Express. To specify this setting, you must first enable ENA Express.</p>
     pub ena_srd_udp_enabled: ::std::option::Option<bool>,
-9
+}
 impl LaunchTemplateEnaSrdUdpSpecification {
     /// <p>Indicates whether UDP traffic to and from the instance uses ENA Express. To specify this setting, you must first enable ENA Express.</p>
     pub fn ena_srd_udp_enabled(&self) -> ::std::option::Option<bool> {
         self.ena_srd_udp_enabled
-14
+    }
-15
+}
 static LAUNCHTEMPLATEENASRDUDPSPECIFICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#LaunchTemplateEnaSrdUdpSpecification",

     "com.amazonaws.ec2",
     "LaunchTemplateEnaSrdUdpSpecification",
 );
 static LAUNCHTEMPLATEENASRDUDPSPECIFICATION_MEMBER_ENA_SRD_UDP_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#LaunchTemplateEnaSrdUdpSpecification$EnaSrdUdpEnabled",
         "com.amazonaws.ec2",
         "LaunchTemplateEnaSrdUdpSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "ena_srd_udp_enabled",
     "EnaSrdUdpEnabled",
 ,
-30
+)
 .with_xml_name("enaSrdUdpEnabled");
 static LAUNCHTEMPLATEENASRDUDPSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LAUNCHTEMPLATEENASRDUDPSPECIFICATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&LAUNCHTEMPLATEENASRDUDPSPECIFICATION_MEMBER_ENA_SRD_UDP_ENABLED],
 );
 impl LaunchTemplateEnaSrdUdpSpecification {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATEENASRDUDPSPECIFICATION_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateEnaSrdUdpSpecification {
     #[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.ena_srd_udp_enabled {
             ser.write_boolean(&LAUNCHTEMPLATEENASRDUDPSPECIFICATION_MEMBER_ENA_SRD_UDP_ENABLED, *val)?;
-49
+        }
         Ok(())
-51
+    }
-52
+}
 impl LaunchTemplateEnaSrdUdpSpecification {
     /// 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(&LAUNCHTEMPLATEENASRDUDPSPECIFICATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LAUNCHTEMPLATEENASRDUDPSPECIFICATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.ena_srd_udp_enabled = Some(deser.read_boolean(member)?);
-71
+                }
                 _ => {}
-73
+            }
             Ok(())
         })?;
         Ok(builder.build())
-77
+    }
-78
+}
 impl LaunchTemplateEnaSrdUdpSpecification {
     /// 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 LaunchTemplateEnaSrdUdpSpecification {
     /// Creates a new builder-style object to manufacture [`LaunchTemplateEnaSrdUdpSpecification`](crate::types::LaunchTemplateEnaSrdUdpSpecification).
     pub fn builder() -> crate::types::builders::LaunchTemplateEnaSrdUdpSpecificationBuilder {
         crate::types::builders::LaunchTemplateEnaSrdUdpSpecificationBuilder::default()
-94
+    }
-95
+}
-96
 /// A builder for [`LaunchTemplateEnaSrdUdpSpecification`](crate::types::LaunchTemplateEnaSrdUdpSpecification).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct LaunchTemplateEnaSrdUdpSpecificationBuilder {
     pub(crate) ena_srd_udp_enabled: ::std::option::Option<bool>,
-102
+}
 impl LaunchTemplateEnaSrdUdpSpecificationBuilder {
     /// <p>Indicates whether UDP traffic to and from the instance uses ENA Express. To specify this setting, you must first enable ENA Express.</p>
     pub fn ena_srd_udp_enabled(mut self, input: bool) -> Self {
         self.ena_srd_udp_enabled = ::std::option::Option::Some(input);
         self
-108
+    }
     /// <p>Indicates whether UDP traffic to and from the instance uses ENA Express. To specify this setting, you must first enable ENA Express.</p>
     pub fn set_ena_srd_udp_enabled(mut self, input: ::std::option::Option<bool>) -> Self {
         self.ena_srd_udp_enabled = input;
         self
-113
+    }
     /// <p>Indicates whether UDP traffic to and from the instance uses ENA Express. To specify this setting, you must first enable ENA Express.</p>
     pub fn get_ena_srd_udp_enabled(&self) -> &::std::option::Option<bool> {
         &self.ena_srd_udp_enabled
-117
+    }
     /// Consumes the builder and constructs a [`LaunchTemplateEnaSrdUdpSpecification`](crate::types::LaunchTemplateEnaSrdUdpSpecification).
     pub fn build(self) -> crate::types::LaunchTemplateEnaSrdUdpSpecification {

AWS SDK

Files changed: