AWS SDK

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

@@ -163,163 +421,421 @@

         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("monitoring", &self.monitoring);
         formatter.field("network_interfaces", &self.network_interfaces);
         formatter.field("placement", &self.placement);
         formatter.field("ramdisk_id", &self.ramdisk_id);
         formatter.field("spot_price", &self.spot_price);
         formatter.field("subnet_id", &self.subnet_id);
         formatter.field("user_data", &"*** Sensitive Data Redacted ***");
         formatter.field("weighted_capacity", &self.weighted_capacity);
         formatter.field("tag_specifications", &self.tag_specifications);
         formatter.field("instance_requirements", &self.instance_requirements);
         formatter.field("security_groups", &self.security_groups);
         formatter.finish()
-179
+    }
-180
+}
 static SPOTFLEETLAUNCHSPECIFICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#SpotFleetLaunchSpecification",

     "com.amazonaws.ec2",
     "SpotFleetLaunchSpecification",
 );
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_ADDRESSING_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$AddressingType",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "addressing_type",
     "AddressingType",
 ,
-195
+)
 .with_xml_name("addressingType");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_BLOCK_DEVICE_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$BlockDeviceMappings",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "block_device_mappings",
     "BlockDeviceMappings",
 ,
-206
+)
 .with_xml_name("blockDeviceMapping");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_EBS_OPTIMIZED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$EbsOptimized",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "ebs_optimized",
     "EbsOptimized",
 ,
-217
+)
 .with_xml_name("ebsOptimized");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_IAM_INSTANCE_PROFILE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$IamInstanceProfile",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "iam_instance_profile",
     "IamInstanceProfile",
 ,
-228
+)
 .with_xml_name("iamInstanceProfile");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$ImageId",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "image_id",
     "ImageId",
 ,
-239
+)
 .with_xml_name("imageId");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$InstanceType",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_type",
     "InstanceType",
 ,
-250
+)
 .with_xml_name("instanceType");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_KERNEL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$KernelId",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "kernel_id",
     "KernelId",
 ,
-261
+)
 .with_xml_name("kernelId");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_KEY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$KeyName",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "key_name",
     "KeyName",
 ,
-272
+)
 .with_xml_name("keyName");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_MONITORING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$Monitoring",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "monitoring",
     "Monitoring",
 ,
-283
+)
 .with_xml_name("monitoring");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_NETWORK_INTERFACES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$NetworkInterfaces",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "network_interfaces",
     "NetworkInterfaces",
 ,
-294
+)
 .with_xml_name("networkInterfaceSet");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_PLACEMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$Placement",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "placement",
     "Placement",
 ,
-305
+)
 .with_xml_name("placement");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_RAMDISK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$RamdiskId",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ramdisk_id",
     "RamdiskId",
 ,
-316
+)
 .with_xml_name("ramdiskId");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_SPOT_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$SpotPrice",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "spot_price",
     "SpotPrice",
 ,
-327
+)
 .with_xml_name("spotPrice");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$SubnetId",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "subnet_id",
     "SubnetId",
 ,
-338
+)
 .with_xml_name("subnetId");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_USER_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$UserData",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "user_data",
     "UserData",
 ,
-349
+)
 .with_xml_name("userData");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_WEIGHTED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$WeightedCapacity",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "weighted_capacity",
     "WeightedCapacity",
 ,
-360
+)
 .with_xml_name("weightedCapacity");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$TagSpecifications",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_specifications",
     "TagSpecifications",
 ,
-371
+)
 .with_xml_name("tagSpecificationSet");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_INSTANCE_REQUIREMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$InstanceRequirements",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "instance_requirements",
     "InstanceRequirements",
 ,
-382
+)
 .with_xml_name("instanceRequirements");
 static SPOTFLEETLAUNCHSPECIFICATION_MEMBER_SECURITY_GROUPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetLaunchSpecification$SecurityGroups",
         "com.amazonaws.ec2",
         "SpotFleetLaunchSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "security_groups",
     "SecurityGroups",
 ,
-393
+)
 .with_xml_name("groupSet");
 static SPOTFLEETLAUNCHSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTFLEETLAUNCHSPECIFICATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_ADDRESSING_TYPE,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_BLOCK_DEVICE_MAPPINGS,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_EBS_OPTIMIZED,

↧ Expand context

         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_IAM_INSTANCE_PROFILE,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_IMAGE_ID,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_INSTANCE_TYPE,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_KERNEL_ID,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_KEY_NAME,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_MONITORING,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_NETWORK_INTERFACES,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_PLACEMENT,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_RAMDISK_ID,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_SPOT_PRICE,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_SUBNET_ID,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_USER_DATA,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_WEIGHTED_CAPACITY,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_TAG_SPECIFICATIONS,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_INSTANCE_REQUIREMENTS,
         &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_SECURITY_GROUPS,
     ],
 );
 impl SpotFleetLaunchSpecification {
     /// The schema for this shape.

@@ -494,494 +671,670 @@

↥ Expand context

         if let Some(ref val) = self.tag_specifications {
             ser.write_list(
                 &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_TAG_SPECIFICATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::SpotFleetTagSpecification::SCHEMA, item)?;
-500
+                    }
                     Ok(())
                 },
             )?;
-504
+        }
         if let Some(ref val) = self.instance_requirements {
             ser.write_struct(&SPOTFLEETLAUNCHSPECIFICATION_MEMBER_INSTANCE_REQUIREMENTS, val)?;
-507
+        }
         if let Some(ref val) = self.security_groups {
             ser.write_list(
                 &SPOTFLEETLAUNCHSPECIFICATION_MEMBER_SECURITY_GROUPS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::GroupIdentifier::SCHEMA, item)?;

-514
+                    }
                     Ok(())
                 },
             )?;
-518
+        }
         Ok(())
-520
+    }
-521
+}
 impl SpotFleetLaunchSpecification {
     /// 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(&SPOTFLEETLAUNCHSPECIFICATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTFLEETLAUNCHSPECIFICATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.addressing_type = Some(deser.read_string(member)?);
-540
+                }
                 Some(1) => {
                     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
                     });
-550
+                }
                 Some(2) => {
                     builder.ebs_optimized = Some(deser.read_boolean(member)?);
-553
+                }
                 Some(3) => {
                     builder.iam_instance_profile = Some(crate::types::IamInstanceProfileSpecification::deserialize(deser)?);
-556
+                }
                 Some(4) => {
                     builder.image_id = Some(deser.read_string(member)?);
-559
+                }
                 Some(5) => {
                     builder.instance_type = Some(crate::types::InstanceType::from(deser.read_string(member)?.as_str()));
-562
+                }
                 Some(6) => {
                     builder.kernel_id = Some(deser.read_string(member)?);
-565
+                }
                 Some(7) => {
                     builder.key_name = Some(deser.read_string(member)?);
-568
+                }
                 Some(8) => {
                     builder.monitoring = Some(crate::types::SpotFleetMonitoring::deserialize(deser)?);
-571
+                }
                 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
                     });
-581
+                }
                 Some(10) => {
                     builder.placement = Some(crate::types::SpotPlacement::deserialize(deser)?);
-584
+                }
                 Some(11) => {
                     builder.ramdisk_id = Some(deser.read_string(member)?);
-587
+                }
                 Some(12) => {
                     builder.spot_price = Some(deser.read_string(member)?);
-590
+                }
                 Some(13) => {
                     builder.subnet_id = Some(deser.read_string(member)?);
-593
+                }
                 Some(14) => {
                     builder.user_data = Some(deser.read_string(member)?);
-596
+                }
                 Some(15) => {
                     builder.weighted_capacity = Some(deser.read_double(member)?);
-599
+                }
                 Some(16) => {
                     builder.tag_specifications = 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::SpotFleetTagSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::SpotFleetTagSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-609
+                }
                 Some(17) => {
                     builder.instance_requirements = Some(crate::types::InstanceRequirements::deserialize(deser)?);
-612
+                }
                 Some(18) => {
                     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
                     });
-622
+                }
                 _ => {}
-624
+            }
             Ok(())
         })?;
         Ok(builder.build())
-628
+    }
-629
+}
 impl SpotFleetLaunchSpecification {
     /// 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 SpotFleetLaunchSpecification {
     /// Creates a new builder-style object to manufacture [`SpotFleetLaunchSpecification`](crate::types::SpotFleetLaunchSpecification).
     pub fn builder() -> crate::types::builders::SpotFleetLaunchSpecificationBuilder {
         crate::types::builders::SpotFleetLaunchSpecificationBuilder::default()
-645
+    }
-646
+}
-647
 /// A builder for [`SpotFleetLaunchSpecification`](crate::types::SpotFleetLaunchSpecification).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotFleetLaunchSpecificationBuilder {
     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) monitoring: ::std::option::Option<crate::types::SpotFleetMonitoring>,
     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) spot_price: ::std::option::Option<::std::string::String>,
     pub(crate) subnet_id: ::std::option::Option<::std::string::String>,
     pub(crate) user_data: ::std::option::Option<::std::string::String>,
     pub(crate) weighted_capacity: ::std::option::Option<f64>,
     pub(crate) tag_specifications: ::std::option::Option<::std::vec::Vec<crate::types::SpotFleetTagSpecification>>,
     pub(crate) instance_requirements: ::std::option::Option<crate::types::InstanceRequirements>,
     pub(crate) security_groups: ::std::option::Option<::std::vec::Vec<crate::types::GroupIdentifier>>,

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

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Describes whether monitoring is enabled.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct SpotFleetMonitoring {
     /// <p>Enables monitoring for the instance.</p>
     /// <p>Default: <code>false</code></p>
     pub enabled: ::std::option::Option<bool>,
-10
+}
 impl SpotFleetMonitoring {
     /// <p>Enables monitoring for the instance.</p>
     /// <p>Default: <code>false</code></p>
     pub fn enabled(&self) -> ::std::option::Option<bool> {
         self.enabled
-16
+    }

-17
+}
 static SPOTFLEETMONITORING_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotFleetMonitoring", "com.amazonaws.ec2", "SpotFleetMonitoring");
 static SPOTFLEETMONITORING_MEMBER_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetMonitoring$Enabled",
         "com.amazonaws.ec2",
         "SpotFleetMonitoring",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "enabled",
     "Enabled",
 ,
-29
+)
 .with_xml_name("enabled");
 static SPOTFLEETMONITORING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTFLEETMONITORING_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&SPOTFLEETMONITORING_MEMBER_ENABLED],
 );
 impl SpotFleetMonitoring {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPOTFLEETMONITORING_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SpotFleetMonitoring {
     #[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.enabled {
             ser.write_boolean(&SPOTFLEETMONITORING_MEMBER_ENABLED, *val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl SpotFleetMonitoring {
     /// 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(&SPOTFLEETMONITORING_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTFLEETMONITORING_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.enabled = Some(deser.read_boolean(member)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl SpotFleetMonitoring {
     /// 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 SpotFleetMonitoring {
     /// Creates a new builder-style object to manufacture [`SpotFleetMonitoring`](crate::types::SpotFleetMonitoring).
     pub fn builder() -> crate::types::builders::SpotFleetMonitoringBuilder {
         crate::types::builders::SpotFleetMonitoringBuilder::default()
-93
+    }
-94
+}
-95
 /// A builder for [`SpotFleetMonitoring`](crate::types::SpotFleetMonitoring).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotFleetMonitoringBuilder {
     pub(crate) enabled: ::std::option::Option<bool>,
-101
+}
 impl SpotFleetMonitoringBuilder {
     /// <p>Enables monitoring for the instance.</p>
     /// <p>Default: <code>false</code></p>
     pub fn enabled(mut self, input: bool) -> Self {
         self.enabled = ::std::option::Option::Some(input);
         self
-108
+    }
     /// <p>Enables monitoring for the instance.</p>
     /// <p>Default: <code>false</code></p>
     pub fn set_enabled(mut self, input: ::std::option::Option<bool>) -> Self {
         self.enabled = input;
         self
-114
+    }
     /// <p>Enables monitoring for the instance.</p>
     /// <p>Default: <code>false</code></p>
     pub fn get_enabled(&self) -> &::std::option::Option<bool> {
         &self.enabled

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

@@ -27,27 +247,255 @@

↥ Expand context

         self.create_time.as_ref()
-28
+    }
     /// <p>The configuration of the Spot Fleet request.</p>
     pub fn spot_fleet_request_config(&self) -> ::std::option::Option<&crate::types::SpotFleetRequestConfigData> {
         self.spot_fleet_request_config.as_ref()
-32
+    }
     /// <p>The ID of the Spot Fleet request.</p>
     pub fn spot_fleet_request_id(&self) -> ::std::option::Option<&str> {
         self.spot_fleet_request_id.as_deref()
-36
+    }
     /// <p>The state of the Spot Fleet request.</p>
     pub fn spot_fleet_request_state(&self) -> ::std::option::Option<&crate::types::BatchState> {
         self.spot_fleet_request_state.as_ref()
-40
+    }
     /// <p>The tags for a Spot Fleet resource.</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()
-46
+    }

-47
+}
 static SPOTFLEETREQUESTCONFIG_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotFleetRequestConfig", "com.amazonaws.ec2", "SpotFleetRequestConfig");
 static SPOTFLEETREQUESTCONFIG_MEMBER_ACTIVITY_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfig$ActivityStatus",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfig",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "activity_status",
     "ActivityStatus",
 ,
-59
+)
 .with_xml_name("activityStatus");
 static SPOTFLEETREQUESTCONFIG_MEMBER_CREATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfig$CreateTime",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfig",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "create_time",
     "CreateTime",
 ,
-70
+)
 .with_xml_name("createTime");
 static SPOTFLEETREQUESTCONFIG_MEMBER_SPOT_FLEET_REQUEST_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfig$SpotFleetRequestConfig",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfig",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "spot_fleet_request_config",
     "SpotFleetRequestConfig",
 ,
-81
+)
 .with_xml_name("spotFleetRequestConfig");
 static SPOTFLEETREQUESTCONFIG_MEMBER_SPOT_FLEET_REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfig$SpotFleetRequestId",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfig",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "spot_fleet_request_id",
     "SpotFleetRequestId",
 ,
-92
+)
 .with_xml_name("spotFleetRequestId");
 static SPOTFLEETREQUESTCONFIG_MEMBER_SPOT_FLEET_REQUEST_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfig$SpotFleetRequestState",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfig",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "spot_fleet_request_state",
     "SpotFleetRequestState",
 ,
-103
+)
 .with_xml_name("spotFleetRequestState");
 static SPOTFLEETREQUESTCONFIG_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfig$Tags",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfig",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-114
+)
 .with_xml_name("tagSet");
 static SPOTFLEETREQUESTCONFIG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTFLEETREQUESTCONFIG_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPOTFLEETREQUESTCONFIG_MEMBER_ACTIVITY_STATUS,
         &SPOTFLEETREQUESTCONFIG_MEMBER_CREATE_TIME,
         &SPOTFLEETREQUESTCONFIG_MEMBER_SPOT_FLEET_REQUEST_CONFIG,
         &SPOTFLEETREQUESTCONFIG_MEMBER_SPOT_FLEET_REQUEST_ID,
         &SPOTFLEETREQUESTCONFIG_MEMBER_SPOT_FLEET_REQUEST_STATE,
         &SPOTFLEETREQUESTCONFIG_MEMBER_TAGS,
     ],
 );
 impl SpotFleetRequestConfig {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPOTFLEETREQUESTCONFIG_SCHEMA;
-131
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SpotFleetRequestConfig {
     #[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.activity_status {
             ser.write_string(&SPOTFLEETREQUESTCONFIG_MEMBER_ACTIVITY_STATUS, val.as_str())?;
-140
+        }
         if let Some(ref val) = self.create_time {
             ser.write_timestamp(&SPOTFLEETREQUESTCONFIG_MEMBER_CREATE_TIME, val)?;
-143
+        }
         if let Some(ref val) = self.spot_fleet_request_config {
             ser.write_struct(&SPOTFLEETREQUESTCONFIG_MEMBER_SPOT_FLEET_REQUEST_CONFIG, val)?;
-146
+        }
         if let Some(ref val) = self.spot_fleet_request_id {
             ser.write_string(&SPOTFLEETREQUESTCONFIG_MEMBER_SPOT_FLEET_REQUEST_ID, val)?;
-149
+        }
         if let Some(ref val) = self.spot_fleet_request_state {
             ser.write_string(&SPOTFLEETREQUESTCONFIG_MEMBER_SPOT_FLEET_REQUEST_STATE, val.as_str())?;
-152
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &SPOTFLEETREQUESTCONFIG_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-159
+                    }
                     Ok(())
                 },
             )?;
-163
+        }
         Ok(())
-165
+    }
-166
+}
 impl SpotFleetRequestConfig {
     /// 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(&SPOTFLEETREQUESTCONFIG_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTFLEETREQUESTCONFIG_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.activity_status = Some(crate::types::ActivityStatus::from(deser.read_string(member)?.as_str()));
-185
+                }
                 Some(1) => {
                     builder.create_time = Some(deser.read_timestamp(member)?);
-188
+                }
                 Some(2) => {
                     builder.spot_fleet_request_config = Some(crate::types::SpotFleetRequestConfigData::deserialize(deser)?);
-191
+                }
                 Some(3) => {
                     builder.spot_fleet_request_id = Some(deser.read_string(member)?);
-194
+                }
                 Some(4) => {
                     builder.spot_fleet_request_state = Some(crate::types::BatchState::from(deser.read_string(member)?.as_str()));
-197
+                }
                 Some(5) => {
                     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
                     });
-207
+                }
                 _ => {}
-209
+            }
             Ok(())
         })?;
         Ok(builder.build())
-213
+    }
-214
+}
 impl SpotFleetRequestConfig {
     /// 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 SpotFleetRequestConfig {
     /// Creates a new builder-style object to manufacture [`SpotFleetRequestConfig`](crate::types::SpotFleetRequestConfig).
     pub fn builder() -> crate::types::builders::SpotFleetRequestConfigBuilder {
         crate::types::builders::SpotFleetRequestConfigBuilder::default()
-230
+    }
-231
+}
-232
 /// A builder for [`SpotFleetRequestConfig`](crate::types::SpotFleetRequestConfig).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotFleetRequestConfigBuilder {
     pub(crate) activity_status: ::std::option::Option<crate::types::ActivityStatus>,
     pub(crate) create_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) spot_fleet_request_config: ::std::option::Option<crate::types::SpotFleetRequestConfigData>,
     pub(crate) spot_fleet_request_id: ::std::option::Option<::std::string::String>,
     pub(crate) spot_fleet_request_state: ::std::option::Option<crate::types::BatchState>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-243
+}
 impl SpotFleetRequestConfigBuilder {
     /// <p>The progress of the Spot Fleet request. If there is an error, the status is <code>error</code>. After all requests are placed, the status is <code>pending_fulfillment</code>. If the size of the fleet is equal to or greater than its target capacity, the status is <code>fulfilled</code>. If the size of the fleet is decreased, the status is <code>pending_termination</code> while Spot Instances are terminating.</p>
     pub fn activity_status(mut self, input: crate::types::ActivityStatus) -> Self {
         self.activity_status = ::std::option::Option::Some(input);
         self
-249
+    }
     /// <p>The progress of the Spot Fleet request. If there is an error, the status is <code>error</code>. After all requests are placed, the status is <code>pending_fulfillment</code>. If the size of the fleet is equal to or greater than its target capacity, the status is <code>fulfilled</code>. If the size of the fleet is decreased, the status is <code>pending_termination</code> while Spot Instances are terminating.</p>
     pub fn set_activity_status(mut self, input: ::std::option::Option<crate::types::ActivityStatus>) -> Self {
         self.activity_status = input;
         self
-254
+    }
     /// <p>The progress of the Spot Fleet request. If there is an error, the status is <code>error</code>. After all requests are placed, the status is <code>pending_fulfillment</code>. If the size of the fleet is equal to or greater than its target capacity, the status is <code>fulfilled</code>. If the size of the fleet is decreased, the status is <code>pending_termination</code> while Spot Instances are terminating.</p>

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

@@ -238,238 +573,573 @@

↥ Expand context

         self.instance_pools_to_use_count
-239
+    }
     /// <p>Reserved.</p>
     pub fn context(&self) -> ::std::option::Option<&str> {
         self.context.as_deref()
-243
+    }
     /// <p>The unit for the target capacity. You can specify this parameter only when using attribute-based instance type selection.</p>
     /// <p>Default: <code>units</code> (the number of instances)</p>
     pub fn target_capacity_unit_type(&self) -> ::std::option::Option<&crate::types::TargetCapacityUnitType> {
         self.target_capacity_unit_type.as_ref()
-248
+    }
     /// <p>The key-value pair for tagging the Spot Fleet request on creation. The value for <code>ResourceType</code> must be <code>spot-fleet-request</code>, otherwise the Spot Fleet request fails. To tag instances at launch, specify the tags in the <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template">launch template</a> (valid only if you use <code>LaunchTemplateConfigs</code>) or in the <code> <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotFleetTagSpecification.html">SpotFleetTagSpecification</a> </code> (valid only if you use <code>LaunchSpecifications</code>). For information about tagging after launch, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-resources">Tag your resources</a>.</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 `.tag_specifications.is_none()`.
     pub fn tag_specifications(&self) -> &[crate::types::TagSpecification] {
         self.tag_specifications.as_deref().unwrap_or_default()
-254
+    }
-255
+}
 static SPOTFLEETREQUESTCONFIGDATA_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#SpotFleetRequestConfigData",

     "com.amazonaws.ec2",
     "SpotFleetRequestConfigData",
 );
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_ALLOCATION_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$AllocationStrategy",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "allocation_strategy",
     "AllocationStrategy",
 ,
-270
+)
 .with_xml_name("allocationStrategy");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_ON_DEMAND_ALLOCATION_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$OnDemandAllocationStrategy",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "on_demand_allocation_strategy",
     "OnDemandAllocationStrategy",
 ,
-281
+)
 .with_xml_name("onDemandAllocationStrategy");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_SPOT_MAINTENANCE_STRATEGIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$SpotMaintenanceStrategies",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "spot_maintenance_strategies",
     "SpotMaintenanceStrategies",
 ,
-292
+)
 .with_xml_name("spotMaintenanceStrategies");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$ClientToken",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
-303
+)
 .with_xml_name("clientToken");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_EXCESS_CAPACITY_TERMINATION_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$ExcessCapacityTerminationPolicy",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "excess_capacity_termination_policy",
     "ExcessCapacityTerminationPolicy",
 ,
-314
+)
 .with_xml_name("excessCapacityTerminationPolicy");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_FULFILLED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$FulfilledCapacity",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "fulfilled_capacity",
     "FulfilledCapacity",
 ,
-325
+)
 .with_xml_name("fulfilledCapacity");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_ON_DEMAND_FULFILLED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$OnDemandFulfilledCapacity",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "on_demand_fulfilled_capacity",
     "OnDemandFulfilledCapacity",
 ,
-336
+)
 .with_xml_name("onDemandFulfilledCapacity");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_IAM_FLEET_ROLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$IamFleetRole",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "iam_fleet_role",
     "IamFleetRole",
 ,
-347
+)
 .with_xml_name("iamFleetRole");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_LAUNCH_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$LaunchSpecifications",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "launch_specifications",
     "LaunchSpecifications",
 ,
-358
+)
 .with_xml_name("launchSpecifications");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_LAUNCH_TEMPLATE_CONFIGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$LaunchTemplateConfigs",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "launch_template_configs",
     "LaunchTemplateConfigs",
 ,
-369
+)
 .with_xml_name("launchTemplateConfigs");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_SPOT_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$SpotPrice",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "spot_price",
     "SpotPrice",
 ,
-380
+)
 .with_xml_name("spotPrice");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_TARGET_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$TargetCapacity",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "target_capacity",
     "TargetCapacity",
 ,
-391
+)
 .with_xml_name("targetCapacity");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_ON_DEMAND_TARGET_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$OnDemandTargetCapacity",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "on_demand_target_capacity",
     "OnDemandTargetCapacity",
 ,
-402
+)
 .with_xml_name("onDemandTargetCapacity");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_ON_DEMAND_MAX_TOTAL_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$OnDemandMaxTotalPrice",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "on_demand_max_total_price",
     "OnDemandMaxTotalPrice",
 ,
-413
+)
 .with_xml_name("onDemandMaxTotalPrice");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_SPOT_MAX_TOTAL_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$SpotMaxTotalPrice",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "spot_max_total_price",
     "SpotMaxTotalPrice",
 ,
-424
+)
 .with_xml_name("spotMaxTotalPrice");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_TERMINATE_INSTANCES_WITH_EXPIRATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$TerminateInstancesWithExpiration",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "terminate_instances_with_expiration",
     "TerminateInstancesWithExpiration",
 ,
-435
+)
 .with_xml_name("terminateInstancesWithExpiration");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$Type",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "r##type",
     "Type",
 ,
-446
+)
 .with_xml_name("type");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_VALID_FROM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$ValidFrom",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "valid_from",
     "ValidFrom",
 ,
-457
+)
 .with_xml_name("validFrom");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_VALID_UNTIL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$ValidUntil",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "valid_until",
     "ValidUntil",
 ,
-468
+)
 .with_xml_name("validUntil");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_REPLACE_UNHEALTHY_INSTANCES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$ReplaceUnhealthyInstances",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "replace_unhealthy_instances",
     "ReplaceUnhealthyInstances",
 ,
-479
+)
 .with_xml_name("replaceUnhealthyInstances");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$InstanceInterruptionBehavior",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_interruption_behavior",
     "InstanceInterruptionBehavior",
 ,
-490
+)
 .with_xml_name("instanceInterruptionBehavior");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_LOAD_BALANCERS_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$LoadBalancersConfig",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "load_balancers_config",
     "LoadBalancersConfig",
 ,
-501
+)
 .with_xml_name("loadBalancersConfig");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_INSTANCE_POOLS_TO_USE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$InstancePoolsToUseCount",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "instance_pools_to_use_count",
     "InstancePoolsToUseCount",
 ,
-512
+)
 .with_xml_name("instancePoolsToUseCount");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$Context",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "context",
     "Context",
 ,
-523
+)
 .with_xml_name("context");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_TARGET_CAPACITY_UNIT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$TargetCapacityUnitType",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "target_capacity_unit_type",
     "TargetCapacityUnitType",
 ,
-534
+)
 .with_xml_name("targetCapacityUnitType");
 static SPOTFLEETREQUESTCONFIGDATA_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetRequestConfigData$TagSpecifications",
         "com.amazonaws.ec2",
         "SpotFleetRequestConfigData",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_specifications",
     "TagSpecifications",
 ,
-545
+)
 .with_xml_name("TagSpecification");
 static SPOTFLEETREQUESTCONFIGDATA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTFLEETREQUESTCONFIGDATA_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_ALLOCATION_STRATEGY,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_ON_DEMAND_ALLOCATION_STRATEGY,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_SPOT_MAINTENANCE_STRATEGIES,

↧ Expand context

         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_CLIENT_TOKEN,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_EXCESS_CAPACITY_TERMINATION_POLICY,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_FULFILLED_CAPACITY,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_ON_DEMAND_FULFILLED_CAPACITY,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_IAM_FLEET_ROLE,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_LAUNCH_SPECIFICATIONS,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_LAUNCH_TEMPLATE_CONFIGS,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_SPOT_PRICE,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_TARGET_CAPACITY,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_ON_DEMAND_TARGET_CAPACITY,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_ON_DEMAND_MAX_TOTAL_PRICE,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_SPOT_MAX_TOTAL_PRICE,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_TERMINATE_INSTANCES_WITH_EXPIRATION,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_TYPE,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_VALID_FROM,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_VALID_UNTIL,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_REPLACE_UNHEALTHY_INSTANCES,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_LOAD_BALANCERS_CONFIG,
         &SPOTFLEETREQUESTCONFIGDATA_MEMBER_INSTANCE_POOLS_TO_USE_COUNT,

@@ -666,666 +856,858 @@

↥ Expand context

             ser.write_string(&SPOTFLEETREQUESTCONFIGDATA_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR, val.as_str())?;
-667
+        }
         if let Some(ref val) = self.load_balancers_config {
             ser.write_struct(&SPOTFLEETREQUESTCONFIGDATA_MEMBER_LOAD_BALANCERS_CONFIG, val)?;
-670
+        }
         if let Some(ref val) = self.instance_pools_to_use_count {
             ser.write_integer(&SPOTFLEETREQUESTCONFIGDATA_MEMBER_INSTANCE_POOLS_TO_USE_COUNT, *val)?;
-673
+        }
         if let Some(ref val) = self.context {
             ser.write_string(&SPOTFLEETREQUESTCONFIGDATA_MEMBER_CONTEXT, val)?;
-676
+        }
         if let Some(ref val) = self.target_capacity_unit_type {
             ser.write_string(&SPOTFLEETREQUESTCONFIGDATA_MEMBER_TARGET_CAPACITY_UNIT_TYPE, val.as_str())?;
-679
+        }
         if let Some(ref val) = self.tag_specifications {
             ser.write_list(
                 &SPOTFLEETREQUESTCONFIGDATA_MEMBER_TAG_SPECIFICATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;

-686
+                    }
                     Ok(())
                 },
             )?;
-690
+        }
         Ok(())
-692
+    }
-693
+}
 impl SpotFleetRequestConfigData {
     /// 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(&SPOTFLEETREQUESTCONFIGDATA_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTFLEETREQUESTCONFIGDATA_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.allocation_strategy = Some(crate::types::AllocationStrategy::from(deser.read_string(member)?.as_str()));
-712
+                }
                 Some(1) => {
                     builder.on_demand_allocation_strategy = Some(crate::types::OnDemandAllocationStrategy::from(deser.read_string(member)?.as_str()));
-715
+                }
                 Some(2) => {
                     builder.spot_maintenance_strategies = Some(crate::types::SpotMaintenanceStrategies::deserialize(deser)?);
-718
+                }
                 Some(3) => {
                     builder.client_token = Some(deser.read_string(member)?);
-721
+                }
                 Some(4) => {
                     builder.excess_capacity_termination_policy =
                         Some(crate::types::ExcessCapacityTerminationPolicy::from(deser.read_string(member)?.as_str()));
-725
+                }
                 Some(5) => {
                     builder.fulfilled_capacity = Some(deser.read_double(member)?);
-728
+                }
                 Some(6) => {
                     builder.on_demand_fulfilled_capacity = Some(deser.read_double(member)?);
-731
+                }
                 Some(7) => {
                     builder.iam_fleet_role = Some(deser.read_string(member)?);
-734
+                }
                 Some(8) => {
                     builder.launch_specifications = 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::SpotFleetLaunchSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::SpotFleetLaunchSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-744
+                }
                 Some(9) => {
                     builder.launch_template_configs = 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::LaunchTemplateConfig::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::LaunchTemplateConfig::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-754
+                }
                 Some(10) => {
                     builder.spot_price = Some(deser.read_string(member)?);
-757
+                }
                 Some(11) => {
                     builder.target_capacity = Some(deser.read_integer(member)?);
-760
+                }
                 Some(12) => {
                     builder.on_demand_target_capacity = Some(deser.read_integer(member)?);
-763
+                }
                 Some(13) => {
                     builder.on_demand_max_total_price = Some(deser.read_string(member)?);
-766
+                }
                 Some(14) => {
                     builder.spot_max_total_price = Some(deser.read_string(member)?);
-769
+                }
                 Some(15) => {
                     builder.terminate_instances_with_expiration = Some(deser.read_boolean(member)?);
-772
+                }
                 Some(16) => {
                     builder.r#type = Some(crate::types::FleetType::from(deser.read_string(member)?.as_str()));
-775
+                }
                 Some(17) => {
                     builder.valid_from = Some(deser.read_timestamp(member)?);
-778
+                }
                 Some(18) => {
                     builder.valid_until = Some(deser.read_timestamp(member)?);
-781
+                }
                 Some(19) => {
                     builder.replace_unhealthy_instances = Some(deser.read_boolean(member)?);
-784
+                }
                 Some(20) => {
                     builder.instance_interruption_behavior =
                         Some(crate::types::InstanceInterruptionBehavior::from(deser.read_string(member)?.as_str()));
-788
+                }
                 Some(21) => {
                     builder.load_balancers_config = Some(crate::types::LoadBalancersConfig::deserialize(deser)?);
-791
+                }
                 Some(22) => {
                     builder.instance_pools_to_use_count = Some(deser.read_integer(member)?);
-794
+                }
                 Some(23) => {
                     builder.context = Some(deser.read_string(member)?);
-797
+                }
                 Some(24) => {
                     builder.target_capacity_unit_type = Some(crate::types::TargetCapacityUnitType::from(deser.read_string(member)?.as_str()));
-800
+                }
                 Some(25) => {
                     builder.tag_specifications = 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::TagSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-810
+                }
                 _ => {}
-812
+            }
             Ok(())
         })?;
         Ok(builder.build())
-816
+    }
-817
+}
 impl SpotFleetRequestConfigData {
     /// 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 SpotFleetRequestConfigData {
     /// Creates a new builder-style object to manufacture [`SpotFleetRequestConfigData`](crate::types::SpotFleetRequestConfigData).
     pub fn builder() -> crate::types::builders::SpotFleetRequestConfigDataBuilder {
         crate::types::builders::SpotFleetRequestConfigDataBuilder::default()
-833
+    }
-834
+}
-835
 /// A builder for [`SpotFleetRequestConfigData`](crate::types::SpotFleetRequestConfigData).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotFleetRequestConfigDataBuilder {
     pub(crate) allocation_strategy: ::std::option::Option<crate::types::AllocationStrategy>,
     pub(crate) on_demand_allocation_strategy: ::std::option::Option<crate::types::OnDemandAllocationStrategy>,
     pub(crate) spot_maintenance_strategies: ::std::option::Option<crate::types::SpotMaintenanceStrategies>,
     pub(crate) client_token: ::std::option::Option<::std::string::String>,
     pub(crate) excess_capacity_termination_policy: ::std::option::Option<crate::types::ExcessCapacityTerminationPolicy>,
     pub(crate) fulfilled_capacity: ::std::option::Option<f64>,
     pub(crate) on_demand_fulfilled_capacity: ::std::option::Option<f64>,
     pub(crate) iam_fleet_role: ::std::option::Option<::std::string::String>,
     pub(crate) launch_specifications: ::std::option::Option<::std::vec::Vec<crate::types::SpotFleetLaunchSpecification>>,
     pub(crate) launch_template_configs: ::std::option::Option<::std::vec::Vec<crate::types::LaunchTemplateConfig>>,
     pub(crate) spot_price: ::std::option::Option<::std::string::String>,
     pub(crate) target_capacity: ::std::option::Option<i32>,
     pub(crate) on_demand_target_capacity: ::std::option::Option<i32>,
     pub(crate) on_demand_max_total_price: ::std::option::Option<::std::string::String>,
     pub(crate) spot_max_total_price: ::std::option::Option<::std::string::String>,
     pub(crate) terminate_instances_with_expiration: ::std::option::Option<bool>,
     pub(crate) r#type: ::std::option::Option<crate::types::FleetType>,
     pub(crate) valid_from: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) valid_until: ::std::option::Option<::aws_smithy_types::DateTime>,

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

@@ -6,6 +151,159 @@

↥ Expand context

 pub struct SpotFleetTagSpecification {
     /// <p>The type of resource. Currently, the only resource type that is supported is <code>instance</code>. To tag the Spot Fleet request on creation, use the <code>TagSpecifications</code> parameter in <code> <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotFleetRequestConfigData.html">SpotFleetRequestConfigData</a> </code>.</p>
     pub resource_type: ::std::option::Option<crate::types::ResourceType>,
     /// <p>The tags.</p>
     pub tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-11
+}
 impl SpotFleetTagSpecification {
     /// <p>The type of resource. Currently, the only resource type that is supported is <code>instance</code>. To tag the Spot Fleet request on creation, use the <code>TagSpecifications</code> parameter in <code> <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotFleetRequestConfigData.html">SpotFleetRequestConfigData</a> </code>.</p>
     pub fn resource_type(&self) -> ::std::option::Option<&crate::types::ResourceType> {
         self.resource_type.as_ref()
-16
+    }
     /// <p>The tags.</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()
-22
+    }
-23
+}
 static SPOTFLEETTAGSPECIFICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#SpotFleetTagSpecification",

     "com.amazonaws.ec2",
     "SpotFleetTagSpecification",
 );
 static SPOTFLEETTAGSPECIFICATION_MEMBER_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetTagSpecification$ResourceType",
         "com.amazonaws.ec2",
         "SpotFleetTagSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_type",
     "ResourceType",
 ,
-38
+)
 .with_xml_name("resourceType");
 static SPOTFLEETTAGSPECIFICATION_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotFleetTagSpecification$Tags",
         "com.amazonaws.ec2",
         "SpotFleetTagSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-49
+)
 .with_xml_name("tag");
 static SPOTFLEETTAGSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTFLEETTAGSPECIFICATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&SPOTFLEETTAGSPECIFICATION_MEMBER_RESOURCE_TYPE, &SPOTFLEETTAGSPECIFICATION_MEMBER_TAGS],
 );
 impl SpotFleetTagSpecification {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPOTFLEETTAGSPECIFICATION_SCHEMA;
-59
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SpotFleetTagSpecification {
     #[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.resource_type {
             ser.write_string(&SPOTFLEETTAGSPECIFICATION_MEMBER_RESOURCE_TYPE, val.as_str())?;
-68
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &SPOTFLEETTAGSPECIFICATION_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-75
+                    }
                     Ok(())
                 },
             )?;
-79
+        }
         Ok(())
-81
+    }
-82
+}
 impl SpotFleetTagSpecification {
     /// 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(&SPOTFLEETTAGSPECIFICATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTFLEETTAGSPECIFICATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_type = Some(crate::types::ResourceType::from(deser.read_string(member)?.as_str()));
-101
+                }
                 Some(1) => {
                     builder.tags = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Tag::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-111
+                }
                 _ => {}
-113
+            }
             Ok(())
         })?;
         Ok(builder.build())
-117
+    }
-118
+}
 impl SpotFleetTagSpecification {
     /// 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 SpotFleetTagSpecification {
     /// Creates a new builder-style object to manufacture [`SpotFleetTagSpecification`](crate::types::SpotFleetTagSpecification).
     pub fn builder() -> crate::types::builders::SpotFleetTagSpecificationBuilder {
         crate::types::builders::SpotFleetTagSpecificationBuilder::default()
-134
+    }
-135
+}
-136
 /// A builder for [`SpotFleetTagSpecification`](crate::types::SpotFleetTagSpecification).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotFleetTagSpecificationBuilder {
     pub(crate) resource_type: ::std::option::Option<crate::types::ResourceType>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-143
+}
 impl SpotFleetTagSpecificationBuilder {
     /// <p>The type of resource. Currently, the only resource type that is supported is <code>instance</code>. To tag the Spot Fleet request on creation, use the <code>TagSpecifications</code> parameter in <code> <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotFleetRequestConfigData.html">SpotFleetRequestConfigData</a> </code>.</p>
     pub fn resource_type(mut self, input: crate::types::ResourceType) -> Self {
         self.resource_type = ::std::option::Option::Some(input);
         self
-149
+    }
     /// <p>The type of resource. Currently, the only resource type that is supported is <code>instance</code>. To tag the Spot Fleet request on creation, use the <code>TagSpecifications</code> parameter in <code> <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotFleetRequestConfigData.html">SpotFleetRequestConfigData</a> </code>.</p>
     pub fn set_resource_type(mut self, input: ::std::option::Option<crate::types::ResourceType>) -> Self {
         self.resource_type = input;
         self
-154
+    }
     /// <p>The type of resource. Currently, the only resource type that is supported is <code>instance</code>. To tag the Spot Fleet request on creation, use the <code>TagSpecifications</code> parameter in <code> <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotFleetRequestConfigData.html">SpotFleetRequestConfigData</a> </code>.</p>
     pub fn get_resource_type(&self) -> &::std::option::Option<crate::types::ResourceType> {
         &self.resource_type
-158
+    }
     /// Appends an item to `tags`.

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

@@ -131,131 +380,380 @@

↥ Expand context

         self.r#type.as_ref()
-132
+    }
     /// <p>The start date of the request, in UTC format (for example, <i>YYYY</i>-<i>MM</i>-<i>DD</i>T<i>HH</i>:<i>MM</i>:<i>SS</i>Z). The request becomes active at this date and time.</p>
     pub fn valid_from(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.valid_from.as_ref()
-136
+    }
     /// <p>The end date of the request, in UTC format (<i>YYYY</i>-<i>MM</i>-<i>DD</i>T<i>HH</i>:<i>MM</i>:<i>SS</i>Z).</p>
     /// <ul>
     /// <li>
     /// <p>For a persistent request, the request remains active until the <code>validUntil</code> date and time is reached. Otherwise, the request remains active until you cancel it.</p></li>
     /// <li>
     /// <p>For a one-time request, the request remains active until all instances launch, the request is canceled, or the <code>validUntil</code> date and time is reached. By default, the request is valid for 7 days from the date the request was created.</p></li>
     /// </ul>
     pub fn valid_until(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.valid_until.as_ref()
-146
+    }
     /// <p>The behavior when a Spot Instance is interrupted.</p>
     pub fn instance_interruption_behavior(&self) -> ::std::option::Option<&crate::types::InstanceInterruptionBehavior> {
         self.instance_interruption_behavior.as_ref()
-150
+    }

-151
+}
 static SPOTINSTANCEREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotInstanceRequest", "com.amazonaws.ec2", "SpotInstanceRequest");
 static SPOTINSTANCEREQUEST_MEMBER_ACTUAL_BLOCK_HOURLY_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$ActualBlockHourlyPrice",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "actual_block_hourly_price",
     "ActualBlockHourlyPrice",
 ,
-163
+)
 .with_xml_name("actualBlockHourlyPrice");
 static SPOTINSTANCEREQUEST_MEMBER_AVAILABILITY_ZONE_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$AvailabilityZoneGroup",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone_group",
     "AvailabilityZoneGroup",
 ,
-174
+)
 .with_xml_name("availabilityZoneGroup");
 static SPOTINSTANCEREQUEST_MEMBER_BLOCK_DURATION_MINUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$BlockDurationMinutes",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "block_duration_minutes",
     "BlockDurationMinutes",
 ,
-185
+)
 .with_xml_name("blockDurationMinutes");
 static SPOTINSTANCEREQUEST_MEMBER_CREATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$CreateTime",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "create_time",
     "CreateTime",
 ,
-196
+)
 .with_xml_name("createTime");
 static SPOTINSTANCEREQUEST_MEMBER_FAULT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotInstanceRequest$Fault", "com.amazonaws.ec2", "SpotInstanceRequest"),
     ::aws_smithy_schema::ShapeType::Structure,
     "fault",
     "Fault",
 ,
-203
+)
 .with_xml_name("fault");
 static SPOTINSTANCEREQUEST_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$InstanceId",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_id",
     "InstanceId",
 ,
-214
+)
 .with_xml_name("instanceId");
 static SPOTINSTANCEREQUEST_MEMBER_LAUNCH_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$LaunchGroup",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "launch_group",
     "LaunchGroup",
 ,
-225
+)
 .with_xml_name("launchGroup");
 static SPOTINSTANCEREQUEST_MEMBER_LAUNCH_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$LaunchSpecification",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "launch_specification",
     "LaunchSpecification",
 ,
-236
+)
 .with_xml_name("launchSpecification");
 static SPOTINSTANCEREQUEST_MEMBER_LAUNCHED_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$LaunchedAvailabilityZone",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "launched_availability_zone",
     "LaunchedAvailabilityZone",
 ,
-247
+)
 .with_xml_name("launchedAvailabilityZone");
 static SPOTINSTANCEREQUEST_MEMBER_LAUNCHED_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$LaunchedAvailabilityZoneId",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "launched_availability_zone_id",
     "LaunchedAvailabilityZoneId",
 ,
-258
+)
 .with_xml_name("launchedAvailabilityZoneId");
 static SPOTINSTANCEREQUEST_MEMBER_PRODUCT_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$ProductDescription",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "product_description",
     "ProductDescription",
 ,
-269
+)
 .with_xml_name("productDescription");
 static SPOTINSTANCEREQUEST_MEMBER_SPOT_INSTANCE_REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$SpotInstanceRequestId",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "spot_instance_request_id",
     "SpotInstanceRequestId",
 ,
-280
+)
 .with_xml_name("spotInstanceRequestId");
 static SPOTINSTANCEREQUEST_MEMBER_SPOT_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$SpotPrice",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "spot_price",
     "SpotPrice",
 ,
-291
+)
 .with_xml_name("spotPrice");
 static SPOTINSTANCEREQUEST_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotInstanceRequest$State", "com.amazonaws.ec2", "SpotInstanceRequest"),
     ::aws_smithy_schema::ShapeType::String,
     "state",
     "State",
 ,
-298
+)
 .with_xml_name("state");
 static SPOTINSTANCEREQUEST_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotInstanceRequest$Status", "com.amazonaws.ec2", "SpotInstanceRequest"),
     ::aws_smithy_schema::ShapeType::Structure,
     "status",
     "Status",
 ,
-305
+)
 .with_xml_name("status");
 static SPOTINSTANCEREQUEST_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotInstanceRequest$Tags", "com.amazonaws.ec2", "SpotInstanceRequest"),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-312
+)
 .with_xml_name("tagSet");
 static SPOTINSTANCEREQUEST_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotInstanceRequest$Type", "com.amazonaws.ec2", "SpotInstanceRequest"),
     ::aws_smithy_schema::ShapeType::String,
     "r##type",
     "Type",
 ,
-319
+)
 .with_xml_name("type");
 static SPOTINSTANCEREQUEST_MEMBER_VALID_FROM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$ValidFrom",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "valid_from",
     "ValidFrom",
 ,
-330
+)
 .with_xml_name("validFrom");
 static SPOTINSTANCEREQUEST_MEMBER_VALID_UNTIL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$ValidUntil",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "valid_until",
     "ValidUntil",
 ,
-341
+)
 .with_xml_name("validUntil");
 static SPOTINSTANCEREQUEST_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceRequest$InstanceInterruptionBehavior",
         "com.amazonaws.ec2",
         "SpotInstanceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_interruption_behavior",
     "InstanceInterruptionBehavior",
 ,
-352
+)
 .with_xml_name("instanceInterruptionBehavior");
 static SPOTINSTANCEREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTINSTANCEREQUEST_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPOTINSTANCEREQUEST_MEMBER_ACTUAL_BLOCK_HOURLY_PRICE,
         &SPOTINSTANCEREQUEST_MEMBER_AVAILABILITY_ZONE_GROUP,
         &SPOTINSTANCEREQUEST_MEMBER_BLOCK_DURATION_MINUTES,

↧ Expand context

         &SPOTINSTANCEREQUEST_MEMBER_CREATE_TIME,
         &SPOTINSTANCEREQUEST_MEMBER_FAULT,
         &SPOTINSTANCEREQUEST_MEMBER_INSTANCE_ID,
         &SPOTINSTANCEREQUEST_MEMBER_LAUNCH_GROUP,
         &SPOTINSTANCEREQUEST_MEMBER_LAUNCH_SPECIFICATION,
         &SPOTINSTANCEREQUEST_MEMBER_LAUNCHED_AVAILABILITY_ZONE,
         &SPOTINSTANCEREQUEST_MEMBER_LAUNCHED_AVAILABILITY_ZONE_ID,
         &SPOTINSTANCEREQUEST_MEMBER_PRODUCT_DESCRIPTION,
         &SPOTINSTANCEREQUEST_MEMBER_SPOT_INSTANCE_REQUEST_ID,
         &SPOTINSTANCEREQUEST_MEMBER_SPOT_PRICE,
         &SPOTINSTANCEREQUEST_MEMBER_STATE,
         &SPOTINSTANCEREQUEST_MEMBER_STATUS,
         &SPOTINSTANCEREQUEST_MEMBER_TAGS,
         &SPOTINSTANCEREQUEST_MEMBER_TYPE,
         &SPOTINSTANCEREQUEST_MEMBER_VALID_FROM,
         &SPOTINSTANCEREQUEST_MEMBER_VALID_UNTIL,
         &SPOTINSTANCEREQUEST_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR,
     ],
 );
 impl SpotInstanceRequest {

@@ -433,433 +584,592 @@

↥ Expand context

             ser.write_struct(&SPOTINSTANCEREQUEST_MEMBER_STATUS, val)?;
-434
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &SPOTINSTANCEREQUEST_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-441
+                    }
                     Ok(())
                 },
             )?;
-445
+        }
         if let Some(ref val) = self.r#type {
             ser.write_string(&SPOTINSTANCEREQUEST_MEMBER_TYPE, val.as_str())?;
-448
+        }
         if let Some(ref val) = self.valid_from {
             ser.write_timestamp(&SPOTINSTANCEREQUEST_MEMBER_VALID_FROM, val)?;
-451
+        }
         if let Some(ref val) = self.valid_until {

             ser.write_timestamp(&SPOTINSTANCEREQUEST_MEMBER_VALID_UNTIL, val)?;
-454
+        }
         if let Some(ref val) = self.instance_interruption_behavior {
             ser.write_string(&SPOTINSTANCEREQUEST_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR, val.as_str())?;
-457
+        }
         Ok(())
-459
+    }
-460
+}
 impl SpotInstanceRequest {
     /// 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(&SPOTINSTANCEREQUEST_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTINSTANCEREQUEST_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.actual_block_hourly_price = Some(deser.read_string(member)?);
-479
+                }
                 Some(1) => {
                     builder.availability_zone_group = Some(deser.read_string(member)?);
-482
+                }
                 Some(2) => {
                     builder.block_duration_minutes = Some(deser.read_integer(member)?);
-485
+                }
                 Some(3) => {
                     builder.create_time = Some(deser.read_timestamp(member)?);
-488
+                }
                 Some(4) => {
                     builder.fault = Some(crate::types::SpotInstanceStateFault::deserialize(deser)?);
-491
+                }
                 Some(5) => {
                     builder.instance_id = Some(deser.read_string(member)?);
-494
+                }
                 Some(6) => {
                     builder.launch_group = Some(deser.read_string(member)?);
-497
+                }
                 Some(7) => {
                     builder.launch_specification = Some(crate::types::LaunchSpecification::deserialize(deser)?);
-500
+                }
                 Some(8) => {
                     builder.launched_availability_zone = Some(deser.read_string(member)?);
-503
+                }
                 Some(9) => {
                     builder.launched_availability_zone_id = Some(deser.read_string(member)?);
-506
+                }
                 Some(10) => {
                     builder.product_description = Some(crate::types::RiProductDescription::from(deser.read_string(member)?.as_str()));
-509
+                }
                 Some(11) => {
                     builder.spot_instance_request_id = Some(deser.read_string(member)?);
-512
+                }
                 Some(12) => {
                     builder.spot_price = Some(deser.read_string(member)?);
-515
+                }
                 Some(13) => {
                     builder.state = Some(crate::types::SpotInstanceState::from(deser.read_string(member)?.as_str()));
-518
+                }
                 Some(14) => {
                     builder.status = Some(crate::types::SpotInstanceStatus::deserialize(deser)?);
-521
+                }
                 Some(15) => {
                     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
                     });
-531
+                }
                 Some(16) => {
                     builder.r#type = Some(crate::types::SpotInstanceType::from(deser.read_string(member)?.as_str()));
-534
+                }
                 Some(17) => {
                     builder.valid_from = Some(deser.read_timestamp(member)?);
-537
+                }
                 Some(18) => {
                     builder.valid_until = Some(deser.read_timestamp(member)?);
-540
+                }
                 Some(19) => {
                     builder.instance_interruption_behavior =
                         Some(crate::types::InstanceInterruptionBehavior::from(deser.read_string(member)?.as_str()));
-544
+                }
                 _ => {}
-546
+            }
             Ok(())
         })?;
         Ok(builder.build())
-550
+    }
-551
+}
 impl SpotInstanceRequest {
     /// 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 SpotInstanceRequest {
     /// Creates a new builder-style object to manufacture [`SpotInstanceRequest`](crate::types::SpotInstanceRequest).
     pub fn builder() -> crate::types::builders::SpotInstanceRequestBuilder {
         crate::types::builders::SpotInstanceRequestBuilder::default()
-567
+    }
-568
+}
-569
 /// A builder for [`SpotInstanceRequest`](crate::types::SpotInstanceRequest).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotInstanceRequestBuilder {
     pub(crate) actual_block_hourly_price: ::std::option::Option<::std::string::String>,
     pub(crate) availability_zone_group: ::std::option::Option<::std::string::String>,
     pub(crate) block_duration_minutes: ::std::option::Option<i32>,
     pub(crate) create_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) fault: ::std::option::Option<crate::types::SpotInstanceStateFault>,
     pub(crate) instance_id: ::std::option::Option<::std::string::String>,
     pub(crate) launch_group: ::std::option::Option<::std::string::String>,
     pub(crate) launch_specification: ::std::option::Option<crate::types::LaunchSpecification>,
     pub(crate) launched_availability_zone: ::std::option::Option<::std::string::String>,
     pub(crate) launched_availability_zone_id: ::std::option::Option<::std::string::String>,
     pub(crate) product_description: ::std::option::Option<crate::types::RiProductDescription>,
     pub(crate) spot_instance_request_id: ::std::option::Option<::std::string::String>,
     pub(crate) spot_price: ::std::option::Option<::std::string::String>,
     pub(crate) state: ::std::option::Option<crate::types::SpotInstanceState>,
     pub(crate) status: ::std::option::Option<crate::types::SpotInstanceStatus>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) r#type: ::std::option::Option<crate::types::SpotInstanceType>,
     pub(crate) valid_from: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) valid_until: ::std::option::Option<::aws_smithy_types::DateTime>,

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

@@ -1,1 +128,139 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Describes a Spot Instance state change.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct SpotInstanceStateFault {
     /// <p>The reason code for the Spot Instance state change.</p>
     pub code: ::std::option::Option<::std::string::String>,
     /// <p>The message for the Spot Instance state change.</p>
     pub message: ::std::option::Option<::std::string::String>,
-11
+}
 impl SpotInstanceStateFault {
     /// <p>The reason code for the Spot Instance state change.</p>
     pub fn code(&self) -> ::std::option::Option<&str> {
         self.code.as_deref()
-16
+    }
     /// <p>The message for the Spot Instance state change.</p>
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-20
+    }

-21
+}
 static SPOTINSTANCESTATEFAULT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotInstanceStateFault", "com.amazonaws.ec2", "SpotInstanceStateFault");
 static SPOTINSTANCESTATEFAULT_MEMBER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceStateFault$Code",
         "com.amazonaws.ec2",
         "SpotInstanceStateFault",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "code",
     "Code",
 ,
-33
+)
 .with_xml_name("code");
 static SPOTINSTANCESTATEFAULT_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceStateFault$Message",
         "com.amazonaws.ec2",
         "SpotInstanceStateFault",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
-44
+)
 .with_xml_name("message");
 static SPOTINSTANCESTATEFAULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTINSTANCESTATEFAULT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&SPOTINSTANCESTATEFAULT_MEMBER_CODE, &SPOTINSTANCESTATEFAULT_MEMBER_MESSAGE],
 );
 impl SpotInstanceStateFault {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPOTINSTANCESTATEFAULT_SCHEMA;
-54
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SpotInstanceStateFault {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.code {
             ser.write_string(&SPOTINSTANCESTATEFAULT_MEMBER_CODE, val)?;
-63
+        }
         if let Some(ref val) = self.message {
             ser.write_string(&SPOTINSTANCESTATEFAULT_MEMBER_MESSAGE, val)?;
-66
+        }
         Ok(())
-68
+    }
-69
+}
 impl SpotInstanceStateFault {
     /// 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(&SPOTINSTANCESTATEFAULT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTINSTANCESTATEFAULT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.code = Some(deser.read_string(member)?);
-88
+                }
                 Some(1) => {
                     builder.message = Some(deser.read_string(member)?);
-91
+                }
                 _ => {}
-93
+            }
             Ok(())
         })?;
         Ok(builder.build())
-97
+    }
-98
+}
 impl SpotInstanceStateFault {
     /// 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 SpotInstanceStateFault {
     /// Creates a new builder-style object to manufacture [`SpotInstanceStateFault`](crate::types::SpotInstanceStateFault).
     pub fn builder() -> crate::types::builders::SpotInstanceStateFaultBuilder {
         crate::types::builders::SpotInstanceStateFaultBuilder::default()
-114
+    }
-115
+}
-116
 /// A builder for [`SpotInstanceStateFault`](crate::types::SpotInstanceStateFault).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotInstanceStateFaultBuilder {
     pub(crate) code: ::std::option::Option<::std::string::String>,
     pub(crate) message: ::std::option::Option<::std::string::String>,
-123
+}
 impl SpotInstanceStateFaultBuilder {
     /// <p>The reason code for the Spot Instance state change.</p>
     pub fn code(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.code = ::std::option::Option::Some(input.into());
         self
-129
+    }
     /// <p>The reason code for the Spot Instance state change.</p>
     pub fn set_code(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.code = input;
         self
-134
+    }
     /// <p>The reason code for the Spot Instance state change.</p>
     pub fn get_code(&self) -> &::std::option::Option<::std::string::String> {
         &self.code
-138
+    }
     /// <p>The message for the Spot Instance state change.</p>

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

@@ -3,3 +147,158 @@

↥ Expand context

 /// <p>Describes the status of a Spot Instance request.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct SpotInstanceStatus {
     /// <p>The status code. For a list of status codes, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-request-status.html#spot-instance-request-status-understand">Spot request status codes</a> in the <i>Amazon EC2 User Guide</i>.</p>
     pub code: ::std::option::Option<::std::string::String>,
     /// <p>The description for the status code.</p>
     pub message: ::std::option::Option<::std::string::String>,
     /// <p>The date and time of the most recent status update, in UTC format (for example, <i>YYYY</i>-<i>MM</i>-<i>DD</i>T<i>HH</i>:<i>MM</i>:<i>SS</i>Z).</p>
     pub update_time: ::std::option::Option<::aws_smithy_types::DateTime>,
-13
+}
 impl SpotInstanceStatus {
     /// <p>The status code. For a list of status codes, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-request-status.html#spot-instance-request-status-understand">Spot request status codes</a> in the <i>Amazon EC2 User Guide</i>.</p>
     pub fn code(&self) -> ::std::option::Option<&str> {
         self.code.as_deref()
-18
+    }
     /// <p>The description for the status code.</p>
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-22
+    }

     /// <p>The date and time of the most recent status update, in UTC format (for example, <i>YYYY</i>-<i>MM</i>-<i>DD</i>T<i>HH</i>:<i>MM</i>:<i>SS</i>Z).</p>
     pub fn update_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.update_time.as_ref()
-26
+    }
-27
+}
 static SPOTINSTANCESTATUS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotInstanceStatus", "com.amazonaws.ec2", "SpotInstanceStatus");
 static SPOTINSTANCESTATUS_MEMBER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotInstanceStatus$Code", "com.amazonaws.ec2", "SpotInstanceStatus"),
     ::aws_smithy_schema::ShapeType::String,
     "code",
     "Code",
 ,
-35
+)
 .with_xml_name("code");
 static SPOTINSTANCESTATUS_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotInstanceStatus$Message", "com.amazonaws.ec2", "SpotInstanceStatus"),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
-42
+)
 .with_xml_name("message");
 static SPOTINSTANCESTATUS_MEMBER_UPDATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotInstanceStatus$UpdateTime",
         "com.amazonaws.ec2",
         "SpotInstanceStatus",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "update_time",
     "UpdateTime",
 ,
-53
+)
 .with_xml_name("updateTime");
 static SPOTINSTANCESTATUS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTINSTANCESTATUS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPOTINSTANCESTATUS_MEMBER_CODE,
         &SPOTINSTANCESTATUS_MEMBER_MESSAGE,
         &SPOTINSTANCESTATUS_MEMBER_UPDATE_TIME,
     ],
 );
 impl SpotInstanceStatus {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPOTINSTANCESTATUS_SCHEMA;
-67
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SpotInstanceStatus {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.code {
             ser.write_string(&SPOTINSTANCESTATUS_MEMBER_CODE, val)?;
-76
+        }
         if let Some(ref val) = self.message {
             ser.write_string(&SPOTINSTANCESTATUS_MEMBER_MESSAGE, val)?;
-79
+        }
         if let Some(ref val) = self.update_time {
             ser.write_timestamp(&SPOTINSTANCESTATUS_MEMBER_UPDATE_TIME, val)?;
-82
+        }
         Ok(())
-84
+    }
-85
+}
 impl SpotInstanceStatus {
     /// 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(&SPOTINSTANCESTATUS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTINSTANCESTATUS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.code = Some(deser.read_string(member)?);
-104
+                }
                 Some(1) => {
                     builder.message = Some(deser.read_string(member)?);
-107
+                }
                 Some(2) => {
                     builder.update_time = Some(deser.read_timestamp(member)?);
-110
+                }
                 _ => {}
-112
+            }
             Ok(())
         })?;
         Ok(builder.build())
-116
+    }
-117
+}
 impl SpotInstanceStatus {
     /// 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 SpotInstanceStatus {
     /// Creates a new builder-style object to manufacture [`SpotInstanceStatus`](crate::types::SpotInstanceStatus).
     pub fn builder() -> crate::types::builders::SpotInstanceStatusBuilder {
         crate::types::builders::SpotInstanceStatusBuilder::default()
-133
+    }
-134
+}
-135
 /// A builder for [`SpotInstanceStatus`](crate::types::SpotInstanceStatus).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotInstanceStatusBuilder {
     pub(crate) code: ::std::option::Option<::std::string::String>,
     pub(crate) message: ::std::option::Option<::std::string::String>,
     pub(crate) update_time: ::std::option::Option<::aws_smithy_types::DateTime>,
-143
+}
 impl SpotInstanceStatusBuilder {
     /// <p>The status code. For a list of status codes, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-request-status.html#spot-instance-request-status-understand">Spot request status codes</a> in the <i>Amazon EC2 User Guide</i>.</p>
     pub fn code(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.code = ::std::option::Option::Some(input.into());
         self
-149
+    }
     /// <p>The status code. For a list of status codes, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-request-status.html#spot-instance-request-status-understand">Spot request status codes</a> in the <i>Amazon EC2 User Guide</i>.</p>
     pub fn set_code(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.code = input;
         self
-154
+    }
     /// <p>The status code. For a list of status codes, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-request-status.html#spot-instance-request-status-understand">Spot request status codes</a> in the <i>Amazon EC2 User Guide</i>.</p>
     pub fn get_code(&self) -> &::std::option::Option<::std::string::String> {
         &self.code
-158
+    }

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

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The strategies for managing your Spot Instances that are at an elevated risk of being interrupted.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct SpotMaintenanceStrategies {
     /// <p>The Spot Instance replacement strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-capacity-rebalance.html">Capacity rebalancing</a> in the <i>Amazon EC2 User Guide</i>.</p>
     pub capacity_rebalance: ::std::option::Option<crate::types::SpotCapacityRebalance>,
-9
+}
 impl SpotMaintenanceStrategies {
     /// <p>The Spot Instance replacement strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-capacity-rebalance.html">Capacity rebalancing</a> in the <i>Amazon EC2 User Guide</i>.</p>
     pub fn capacity_rebalance(&self) -> ::std::option::Option<&crate::types::SpotCapacityRebalance> {
         self.capacity_rebalance.as_ref()
-14
+    }
-15
+}
 static SPOTMAINTENANCESTRATEGIES_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#SpotMaintenanceStrategies",

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

↧ Expand context

 pub struct SpotMaintenanceStrategiesBuilder {
     pub(crate) capacity_rebalance: ::std::option::Option<crate::types::SpotCapacityRebalance>,
-102
+}
 impl SpotMaintenanceStrategiesBuilder {
     /// <p>The Spot Instance replacement strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-capacity-rebalance.html">Capacity rebalancing</a> in the <i>Amazon EC2 User Guide</i>.</p>
     pub fn capacity_rebalance(mut self, input: crate::types::SpotCapacityRebalance) -> Self {
         self.capacity_rebalance = ::std::option::Option::Some(input);
         self
-108
+    }
     /// <p>The Spot Instance replacement strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-capacity-rebalance.html">Capacity rebalancing</a> in the <i>Amazon EC2 User Guide</i>.</p>
     pub fn set_capacity_rebalance(mut self, input: ::std::option::Option<crate::types::SpotCapacityRebalance>) -> Self {
         self.capacity_rebalance = input;
         self
-113
+    }
     /// <p>The Spot Instance replacement strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-capacity-rebalance.html">Capacity rebalancing</a> in the <i>Amazon EC2 User Guide</i>.</p>
     pub fn get_capacity_rebalance(&self) -> &::std::option::Option<crate::types::SpotCapacityRebalance> {
         &self.capacity_rebalance
-117
+    }
     /// Consumes the builder and constructs a [`SpotMaintenanceStrategies`](crate::types::SpotMaintenanceStrategies).
     pub fn build(self) -> crate::types::SpotMaintenanceStrategies {

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

@@ -39,39 +215,226 @@

↥ Expand context

     pub fn spot_instance_type(&self) -> ::std::option::Option<&crate::types::SpotInstanceType> {
         self.spot_instance_type.as_ref()
-41
+    }
     /// <p>Deprecated.</p>
     pub fn block_duration_minutes(&self) -> ::std::option::Option<i32> {
         self.block_duration_minutes
-45
+    }
     /// <p>The end date of the request, in UTC format (<i>YYYY</i>-<i>MM</i>-<i>DD</i>T<i>HH</i>:<i>MM</i>:<i>SS</i>Z). Supported only for persistent requests.</p>
     /// <ul>
     /// <li>
     /// <p>For a persistent request, the request remains active until the <code>ValidUntil</code> date and time is reached. Otherwise, the request remains active until you cancel it.</p></li>
     /// <li>
     /// <p>For a one-time request, <code>ValidUntil</code> is not supported. The request remains active until all instances launch or you cancel the request.</p></li>
     /// </ul>
     pub fn valid_until(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.valid_until.as_ref()
-55
+    }
     /// <p>The behavior when a Spot Instance is interrupted.</p>
     /// <p>If <code>Configured</code> (for <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_HibernationOptionsRequest.html"> <code>HibernationOptions</code> </a>) is set to <code>true</code>, the <code>InstanceInterruptionBehavior</code> parameter is automatically set to <code>hibernate</code>. If you set it to <code>stop</code> or <code>terminate</code>, you'll get an error.</p>
     /// <p>If <code>Configured</code> (for <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_HibernationOptionsRequest.html"> <code>HibernationOptions</code> </a>) is set to <code>false</code> or <code>null</code>, the <code>InstanceInterruptionBehavior</code> parameter is automatically set to <code>terminate</code>. You can also set it to <code>stop</code> or <code>hibernate</code>.</p>

     /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/interruption-behavior.html">Interruption behavior</a> in the <i>Amazon EC2 User Guide</i>.</p>
     pub fn instance_interruption_behavior(&self) -> ::std::option::Option<&crate::types::InstanceInterruptionBehavior> {
         self.instance_interruption_behavior.as_ref()
-62
+    }
-63
+}
 static SPOTMARKETOPTIONS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotMarketOptions", "com.amazonaws.ec2", "SpotMarketOptions");
 static SPOTMARKETOPTIONS_MEMBER_MAX_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotMarketOptions$MaxPrice", "com.amazonaws.ec2", "SpotMarketOptions"),
     ::aws_smithy_schema::ShapeType::String,
     "max_price",
     "MaxPrice",
 ,
 );
 static SPOTMARKETOPTIONS_MEMBER_SPOT_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotMarketOptions$SpotInstanceType",
         "com.amazonaws.ec2",
         "SpotMarketOptions",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "spot_instance_type",
     "SpotInstanceType",
 ,
 );
 static SPOTMARKETOPTIONS_MEMBER_BLOCK_DURATION_MINUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotMarketOptions$BlockDurationMinutes",
         "com.amazonaws.ec2",
         "SpotMarketOptions",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "block_duration_minutes",
     "BlockDurationMinutes",
 ,
 );
 static SPOTMARKETOPTIONS_MEMBER_VALID_UNTIL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotMarketOptions$ValidUntil", "com.amazonaws.ec2", "SpotMarketOptions"),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "valid_until",
     "ValidUntil",
 ,
 );
 static SPOTMARKETOPTIONS_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotMarketOptions$InstanceInterruptionBehavior",
         "com.amazonaws.ec2",
         "SpotMarketOptions",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_interruption_behavior",
     "InstanceInterruptionBehavior",
 ,
 );
 static SPOTMARKETOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTMARKETOPTIONS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPOTMARKETOPTIONS_MEMBER_MAX_PRICE,
         &SPOTMARKETOPTIONS_MEMBER_SPOT_INSTANCE_TYPE,
         &SPOTMARKETOPTIONS_MEMBER_BLOCK_DURATION_MINUTES,
         &SPOTMARKETOPTIONS_MEMBER_VALID_UNTIL,
         &SPOTMARKETOPTIONS_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR,
     ],
 );
 impl SpotMarketOptions {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPOTMARKETOPTIONS_SCHEMA;
-122
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SpotMarketOptions {
     #[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.max_price {
             ser.write_string(&SPOTMARKETOPTIONS_MEMBER_MAX_PRICE, val)?;
-131
+        }
         if let Some(ref val) = self.spot_instance_type {
             ser.write_string(&SPOTMARKETOPTIONS_MEMBER_SPOT_INSTANCE_TYPE, val.as_str())?;
-134
+        }
         if let Some(ref val) = self.block_duration_minutes {
             ser.write_integer(&SPOTMARKETOPTIONS_MEMBER_BLOCK_DURATION_MINUTES, *val)?;
-137
+        }
         if let Some(ref val) = self.valid_until {
             ser.write_timestamp(&SPOTMARKETOPTIONS_MEMBER_VALID_UNTIL, val)?;
-140
+        }
         if let Some(ref val) = self.instance_interruption_behavior {
             ser.write_string(&SPOTMARKETOPTIONS_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR, val.as_str())?;
-143
+        }
         Ok(())
-145
+    }
-146
+}
 impl SpotMarketOptions {
     /// 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(&SPOTMARKETOPTIONS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTMARKETOPTIONS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.max_price = Some(deser.read_string(member)?);
-165
+                }
                 Some(1) => {
                     builder.spot_instance_type = Some(crate::types::SpotInstanceType::from(deser.read_string(member)?.as_str()));
-168
+                }
                 Some(2) => {
                     builder.block_duration_minutes = Some(deser.read_integer(member)?);
-171
+                }
                 Some(3) => {
                     builder.valid_until = Some(deser.read_timestamp(member)?);
-174
+                }
                 Some(4) => {
                     builder.instance_interruption_behavior =
                         Some(crate::types::InstanceInterruptionBehavior::from(deser.read_string(member)?.as_str()));
-178
+                }
                 _ => {}
-180
+            }
             Ok(())
         })?;
         Ok(builder.build())
-184
+    }
-185
+}
 impl SpotMarketOptions {
     /// 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 SpotMarketOptions {
     /// Creates a new builder-style object to manufacture [`SpotMarketOptions`](crate::types::SpotMarketOptions).
     pub fn builder() -> crate::types::builders::SpotMarketOptionsBuilder {
         crate::types::builders::SpotMarketOptionsBuilder::default()
-201
+    }
-202
+}
-203
 /// A builder for [`SpotMarketOptions`](crate::types::SpotMarketOptions).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotMarketOptionsBuilder {
     pub(crate) max_price: ::std::option::Option<::std::string::String>,
     pub(crate) spot_instance_type: ::std::option::Option<crate::types::SpotInstanceType>,
     pub(crate) block_duration_minutes: ::std::option::Option<i32>,
     pub(crate) valid_until: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) instance_interruption_behavior: ::std::option::Option<crate::types::InstanceInterruptionBehavior>,
-213
+}
 impl SpotMarketOptionsBuilder {
     /// <p>The maximum hourly price that you're willing to pay for a Spot Instance. We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price.</p><important>
     /// <p>If you specify a maximum price, your Spot Instances will be interrupted more frequently than if you do not specify this parameter.</p>
     /// <p>If you specify a maximum price, it must be more than USD $0.001. Specifying a value below USD $0.001 will result in an <code>InvalidParameterValue</code> error message.</p>
     /// </important>
     pub fn max_price(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.max_price = ::std::option::Option::Some(input.into());
         self
-222
+    }
     /// <p>The maximum hourly price that you're willing to pay for a Spot Instance. We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price.</p><important>
     /// <p>If you specify a maximum price, your Spot Instances will be interrupted more frequently than if you do not specify this parameter.</p>
     /// <p>If you specify a maximum price, it must be more than USD $0.001. Specifying a value below USD $0.001 will result in an <code>InvalidParameterValue</code> error message.</p>
     /// </important>

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

@@ -113,113 +332,343 @@

↥ Expand context

     /// <p>Indicates that the fleet uses a single instance type to launch all Spot Instances in the fleet.</p>
     /// <p>Supported only for fleets of type <code>instant</code>.</p>
     pub fn single_instance_type(&self) -> ::std::option::Option<bool> {
         self.single_instance_type
-117
+    }
     /// <p>Indicates that the fleet launches all Spot Instances into a single Availability Zone.</p>
     /// <p>Supported only for fleets of type <code>instant</code>.</p>
     pub fn single_availability_zone(&self) -> ::std::option::Option<bool> {
         self.single_availability_zone
-122
+    }
     /// <p>The minimum target capacity for Spot Instances in the fleet. If this minimum capacity isn't reached, no instances are launched.</p>
     /// <p>Constraints: Maximum value of <code>1000</code>. Supported only for fleets of type <code>instant</code>.</p>
     /// <p>At least one of the following must be specified: <code>SingleAvailabilityZone</code> | <code>SingleInstanceType</code></p>
     pub fn min_target_capacity(&self) -> ::std::option::Option<i32> {
         self.min_target_capacity
-128
+    }
     /// <p>The maximum amount per hour for Spot Instances that you're willing to pay. We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price.</p><important>
     /// <p>If you specify a maximum price, your Spot Instances will be interrupted more frequently than if you do not specify this parameter.</p>
     /// </important> <note>
     /// <p>If your fleet includes T instances that are configured as <code>unlimited</code>, and if their average CPU usage exceeds the baseline utilization, you will incur a charge for surplus credits. The <code>maxTotalPrice</code> does not account for surplus credits, and, if you use surplus credits, your final cost might be higher than what you specified for <code>maxTotalPrice</code>. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-unlimited-mode-concepts.html#unlimited-mode-surplus-credits">Surplus credits can incur charges</a> in the <i>Amazon EC2 User Guide</i>.</p>

     /// </note>
     pub fn max_total_price(&self) -> ::std::option::Option<&str> {
         self.max_total_price.as_deref()
-136
+    }
-137
+}
 static SPOTOPTIONS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotOptions", "com.amazonaws.ec2", "SpotOptions");
 static SPOTOPTIONS_MEMBER_ALLOCATION_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotOptions$AllocationStrategy", "com.amazonaws.ec2", "SpotOptions"),
     ::aws_smithy_schema::ShapeType::String,
     "allocation_strategy",
     "AllocationStrategy",
 ,
-145
+)
 .with_xml_name("allocationStrategy");
 static SPOTOPTIONS_MEMBER_MAINTENANCE_STRATEGIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotOptions$MaintenanceStrategies", "com.amazonaws.ec2", "SpotOptions"),
     ::aws_smithy_schema::ShapeType::Structure,
     "maintenance_strategies",
     "MaintenanceStrategies",
 ,
-152
+)
 .with_xml_name("maintenanceStrategies");
 static SPOTOPTIONS_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotOptions$InstanceInterruptionBehavior",
         "com.amazonaws.ec2",
         "SpotOptions",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_interruption_behavior",
     "InstanceInterruptionBehavior",
 ,
-163
+)
 .with_xml_name("instanceInterruptionBehavior");
 static SPOTOPTIONS_MEMBER_INSTANCE_POOLS_TO_USE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotOptions$InstancePoolsToUseCount",
         "com.amazonaws.ec2",
         "SpotOptions",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "instance_pools_to_use_count",
     "InstancePoolsToUseCount",
 ,
-174
+)
 .with_xml_name("instancePoolsToUseCount");
 static SPOTOPTIONS_MEMBER_SINGLE_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotOptions$SingleInstanceType", "com.amazonaws.ec2", "SpotOptions"),
     ::aws_smithy_schema::ShapeType::Boolean,
     "single_instance_type",
     "SingleInstanceType",
 ,
-181
+)
 .with_xml_name("singleInstanceType");
 static SPOTOPTIONS_MEMBER_SINGLE_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotOptions$SingleAvailabilityZone", "com.amazonaws.ec2", "SpotOptions"),
     ::aws_smithy_schema::ShapeType::Boolean,
     "single_availability_zone",
     "SingleAvailabilityZone",
 ,
-188
+)
 .with_xml_name("singleAvailabilityZone");
 static SPOTOPTIONS_MEMBER_MIN_TARGET_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotOptions$MinTargetCapacity", "com.amazonaws.ec2", "SpotOptions"),
     ::aws_smithy_schema::ShapeType::Integer,
     "min_target_capacity",
     "MinTargetCapacity",
 ,
-195
+)
 .with_xml_name("minTargetCapacity");
 static SPOTOPTIONS_MEMBER_MAX_TOTAL_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotOptions$MaxTotalPrice", "com.amazonaws.ec2", "SpotOptions"),
     ::aws_smithy_schema::ShapeType::String,
     "max_total_price",
     "MaxTotalPrice",
 ,
-202
+)
 .with_xml_name("maxTotalPrice");
 static SPOTOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTOPTIONS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPOTOPTIONS_MEMBER_ALLOCATION_STRATEGY,
         &SPOTOPTIONS_MEMBER_MAINTENANCE_STRATEGIES,
         &SPOTOPTIONS_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR,
         &SPOTOPTIONS_MEMBER_INSTANCE_POOLS_TO_USE_COUNT,
         &SPOTOPTIONS_MEMBER_SINGLE_INSTANCE_TYPE,
         &SPOTOPTIONS_MEMBER_SINGLE_AVAILABILITY_ZONE,
         &SPOTOPTIONS_MEMBER_MIN_TARGET_CAPACITY,
         &SPOTOPTIONS_MEMBER_MAX_TOTAL_PRICE,
     ],
 );
 impl SpotOptions {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPOTOPTIONS_SCHEMA;
-221
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SpotOptions {
     #[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.allocation_strategy {
             ser.write_string(&SPOTOPTIONS_MEMBER_ALLOCATION_STRATEGY, val.as_str())?;
-230
+        }
         if let Some(ref val) = self.maintenance_strategies {
             ser.write_struct(&SPOTOPTIONS_MEMBER_MAINTENANCE_STRATEGIES, val)?;
-233
+        }
         if let Some(ref val) = self.instance_interruption_behavior {
             ser.write_string(&SPOTOPTIONS_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR, val.as_str())?;
-236
+        }
         if let Some(ref val) = self.instance_pools_to_use_count {
             ser.write_integer(&SPOTOPTIONS_MEMBER_INSTANCE_POOLS_TO_USE_COUNT, *val)?;
-239
+        }
         if let Some(ref val) = self.single_instance_type {
             ser.write_boolean(&SPOTOPTIONS_MEMBER_SINGLE_INSTANCE_TYPE, *val)?;
-242
+        }
         if let Some(ref val) = self.single_availability_zone {
             ser.write_boolean(&SPOTOPTIONS_MEMBER_SINGLE_AVAILABILITY_ZONE, *val)?;
-245
+        }
         if let Some(ref val) = self.min_target_capacity {
             ser.write_integer(&SPOTOPTIONS_MEMBER_MIN_TARGET_CAPACITY, *val)?;
-248
+        }
         if let Some(ref val) = self.max_total_price {
             ser.write_string(&SPOTOPTIONS_MEMBER_MAX_TOTAL_PRICE, val)?;
-251
+        }
         Ok(())
-253
+    }
-254
+}
 impl SpotOptions {
     /// 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(&SPOTOPTIONS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTOPTIONS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.allocation_strategy = Some(crate::types::SpotAllocationStrategy::from(deser.read_string(member)?.as_str()));
-273
+                }
                 Some(1) => {
                     builder.maintenance_strategies = Some(crate::types::FleetSpotMaintenanceStrategies::deserialize(deser)?);
-276
+                }
                 Some(2) => {
                     builder.instance_interruption_behavior =
                         Some(crate::types::SpotInstanceInterruptionBehavior::from(deser.read_string(member)?.as_str()));
-280
+                }
                 Some(3) => {
                     builder.instance_pools_to_use_count = Some(deser.read_integer(member)?);
-283
+                }
                 Some(4) => {
                     builder.single_instance_type = Some(deser.read_boolean(member)?);
-286
+                }
                 Some(5) => {
                     builder.single_availability_zone = Some(deser.read_boolean(member)?);
-289
+                }
                 Some(6) => {
                     builder.min_target_capacity = Some(deser.read_integer(member)?);
-292
+                }
                 Some(7) => {
                     builder.max_total_price = Some(deser.read_string(member)?);
-295
+                }
                 _ => {}
-297
+            }
             Ok(())
         })?;
         Ok(builder.build())
-301
+    }
-302
+}
 impl SpotOptions {
     /// 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 SpotOptions {
     /// Creates a new builder-style object to manufacture [`SpotOptions`](crate::types::SpotOptions).
     pub fn builder() -> crate::types::builders::SpotOptionsBuilder {
         crate::types::builders::SpotOptionsBuilder::default()
-318
+    }
-319
+}
-320
 /// A builder for [`SpotOptions`](crate::types::SpotOptions).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotOptionsBuilder {
     pub(crate) allocation_strategy: ::std::option::Option<crate::types::SpotAllocationStrategy>,
     pub(crate) maintenance_strategies: ::std::option::Option<crate::types::FleetSpotMaintenanceStrategies>,
     pub(crate) instance_interruption_behavior: ::std::option::Option<crate::types::SpotInstanceInterruptionBehavior>,
     pub(crate) instance_pools_to_use_count: ::std::option::Option<i32>,
     pub(crate) single_instance_type: ::std::option::Option<bool>,
     pub(crate) single_availability_zone: ::std::option::Option<bool>,
     pub(crate) min_target_capacity: ::std::option::Option<i32>,
     pub(crate) max_total_price: ::std::option::Option<::std::string::String>,
-333
+}
 impl SpotOptionsBuilder {
     /// <p>The strategy that determines how to allocate the target Spot Instance capacity across the Spot Instance pools specified by the EC2 Fleet launch configuration. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-allocation-strategy.html">Allocation strategies for Spot Instances</a> in the <i>Amazon EC2 User Guide</i>.</p>
     /// <dl>
     /// <dt>
     /// price-capacity-optimized (recommended)
     /// </dt>
     /// <dd>
     /// <p>EC2 Fleet identifies the pools with the highest capacity availability for the number of instances that are launching. This means that we will request Spot Instances from the pools that we believe have the lowest chance of interruption in the near term. EC2 Fleet then requests Spot Instances from the lowest priced of these pools.</p>
     /// </dd>
     /// <dt>

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

@@ -117,117 +348,359 @@

↥ Expand context

-117
+    }
     /// <p>Indicates that the fleet launches all Spot Instances into a single Availability Zone.</p>
     /// <p>Supported only for fleets of type <code>instant</code>.</p>
     pub fn single_availability_zone(&self) -> ::std::option::Option<bool> {
         self.single_availability_zone
-122
+    }
     /// <p>The minimum target capacity for Spot Instances in the fleet. If this minimum capacity isn't reached, no instances are launched.</p>
     /// <p>Constraints: Maximum value of <code>1000</code>. Supported only for fleets of type <code>instant</code>.</p>
     /// <p>At least one of the following must be specified: <code>SingleAvailabilityZone</code> | <code>SingleInstanceType</code></p>
     pub fn min_target_capacity(&self) -> ::std::option::Option<i32> {
         self.min_target_capacity
-128
+    }
     /// <p>The maximum amount per hour for Spot Instances that you're willing to pay. We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price.</p><important>
     /// <p>If you specify a maximum price, your Spot Instances will be interrupted more frequently than if you do not specify this parameter.</p>
     /// </important> <note>
     /// <p>If your fleet includes T instances that are configured as <code>unlimited</code>, and if their average CPU usage exceeds the baseline utilization, you will incur a charge for surplus credits. The <code>MaxTotalPrice</code> does not account for surplus credits, and, if you use surplus credits, your final cost might be higher than what you specified for <code>MaxTotalPrice</code>. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-unlimited-mode-concepts.html#unlimited-mode-surplus-credits">Surplus credits can incur charges</a> in the <i>Amazon EC2 User Guide</i>.</p>
     /// </note>
     pub fn max_total_price(&self) -> ::std::option::Option<&str> {
         self.max_total_price.as_deref()
-136
+    }

-137
+}
 static SPOTOPTIONSREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotOptionsRequest", "com.amazonaws.ec2", "SpotOptionsRequest");
 static SPOTOPTIONSREQUEST_MEMBER_ALLOCATION_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotOptionsRequest$AllocationStrategy",
         "com.amazonaws.ec2",
         "SpotOptionsRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "allocation_strategy",
     "AllocationStrategy",
 ,
 );
 static SPOTOPTIONSREQUEST_MEMBER_MAINTENANCE_STRATEGIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotOptionsRequest$MaintenanceStrategies",
         "com.amazonaws.ec2",
         "SpotOptionsRequest",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "maintenance_strategies",
     "MaintenanceStrategies",
 ,
 );
 static SPOTOPTIONSREQUEST_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotOptionsRequest$InstanceInterruptionBehavior",
         "com.amazonaws.ec2",
         "SpotOptionsRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_interruption_behavior",
     "InstanceInterruptionBehavior",
 ,
 );
 static SPOTOPTIONSREQUEST_MEMBER_INSTANCE_POOLS_TO_USE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotOptionsRequest$InstancePoolsToUseCount",
         "com.amazonaws.ec2",
         "SpotOptionsRequest",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "instance_pools_to_use_count",
     "InstancePoolsToUseCount",
 ,
 );
 static SPOTOPTIONSREQUEST_MEMBER_SINGLE_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotOptionsRequest$SingleInstanceType",
         "com.amazonaws.ec2",
         "SpotOptionsRequest",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "single_instance_type",
     "SingleInstanceType",
 ,
 );
 static SPOTOPTIONSREQUEST_MEMBER_SINGLE_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotOptionsRequest$SingleAvailabilityZone",
         "com.amazonaws.ec2",
         "SpotOptionsRequest",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "single_availability_zone",
     "SingleAvailabilityZone",
 ,
 );
 static SPOTOPTIONSREQUEST_MEMBER_MIN_TARGET_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotOptionsRequest$MinTargetCapacity",
         "com.amazonaws.ec2",
         "SpotOptionsRequest",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "min_target_capacity",
     "MinTargetCapacity",
 ,
 );
 static SPOTOPTIONSREQUEST_MEMBER_MAX_TOTAL_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotOptionsRequest$MaxTotalPrice",
         "com.amazonaws.ec2",
         "SpotOptionsRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "max_total_price",
     "MaxTotalPrice",
 ,
 );
 static SPOTOPTIONSREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTOPTIONSREQUEST_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPOTOPTIONSREQUEST_MEMBER_ALLOCATION_STRATEGY,
         &SPOTOPTIONSREQUEST_MEMBER_MAINTENANCE_STRATEGIES,
         &SPOTOPTIONSREQUEST_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR,
         &SPOTOPTIONSREQUEST_MEMBER_INSTANCE_POOLS_TO_USE_COUNT,
         &SPOTOPTIONSREQUEST_MEMBER_SINGLE_INSTANCE_TYPE,
         &SPOTOPTIONSREQUEST_MEMBER_SINGLE_AVAILABILITY_ZONE,
         &SPOTOPTIONSREQUEST_MEMBER_MIN_TARGET_CAPACITY,
         &SPOTOPTIONSREQUEST_MEMBER_MAX_TOTAL_PRICE,
     ],
 );
 impl SpotOptionsRequest {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPOTOPTIONSREQUEST_SCHEMA;
-237
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SpotOptionsRequest {
     #[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.allocation_strategy {
             ser.write_string(&SPOTOPTIONSREQUEST_MEMBER_ALLOCATION_STRATEGY, val.as_str())?;
-246
+        }
         if let Some(ref val) = self.maintenance_strategies {
             ser.write_struct(&SPOTOPTIONSREQUEST_MEMBER_MAINTENANCE_STRATEGIES, val)?;
-249
+        }
         if let Some(ref val) = self.instance_interruption_behavior {
             ser.write_string(&SPOTOPTIONSREQUEST_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR, val.as_str())?;
-252
+        }
         if let Some(ref val) = self.instance_pools_to_use_count {
             ser.write_integer(&SPOTOPTIONSREQUEST_MEMBER_INSTANCE_POOLS_TO_USE_COUNT, *val)?;
-255
+        }
         if let Some(ref val) = self.single_instance_type {
             ser.write_boolean(&SPOTOPTIONSREQUEST_MEMBER_SINGLE_INSTANCE_TYPE, *val)?;
-258
+        }
         if let Some(ref val) = self.single_availability_zone {
             ser.write_boolean(&SPOTOPTIONSREQUEST_MEMBER_SINGLE_AVAILABILITY_ZONE, *val)?;
-261
+        }
         if let Some(ref val) = self.min_target_capacity {
             ser.write_integer(&SPOTOPTIONSREQUEST_MEMBER_MIN_TARGET_CAPACITY, *val)?;
-264
+        }
         if let Some(ref val) = self.max_total_price {
             ser.write_string(&SPOTOPTIONSREQUEST_MEMBER_MAX_TOTAL_PRICE, val)?;
-267
+        }
         Ok(())
-269
+    }
-270
+}
 impl SpotOptionsRequest {
     /// 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(&SPOTOPTIONSREQUEST_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTOPTIONSREQUEST_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.allocation_strategy = Some(crate::types::SpotAllocationStrategy::from(deser.read_string(member)?.as_str()));
-289
+                }
                 Some(1) => {
                     builder.maintenance_strategies = Some(crate::types::FleetSpotMaintenanceStrategiesRequest::deserialize(deser)?);
-292
+                }
                 Some(2) => {
                     builder.instance_interruption_behavior =
                         Some(crate::types::SpotInstanceInterruptionBehavior::from(deser.read_string(member)?.as_str()));
-296
+                }
                 Some(3) => {
                     builder.instance_pools_to_use_count = Some(deser.read_integer(member)?);
-299
+                }
                 Some(4) => {
                     builder.single_instance_type = Some(deser.read_boolean(member)?);
-302
+                }
                 Some(5) => {
                     builder.single_availability_zone = Some(deser.read_boolean(member)?);
-305
+                }
                 Some(6) => {
                     builder.min_target_capacity = Some(deser.read_integer(member)?);
-308
+                }
                 Some(7) => {
                     builder.max_total_price = Some(deser.read_string(member)?);
-311
+                }
                 _ => {}
-313
+            }
             Ok(())
         })?;
         Ok(builder.build())
-317
+    }
-318
+}
 impl SpotOptionsRequest {
     /// 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 SpotOptionsRequest {
     /// Creates a new builder-style object to manufacture [`SpotOptionsRequest`](crate::types::SpotOptionsRequest).
     pub fn builder() -> crate::types::builders::SpotOptionsRequestBuilder {
         crate::types::builders::SpotOptionsRequestBuilder::default()
-334
+    }
-335
+}
-336
 /// A builder for [`SpotOptionsRequest`](crate::types::SpotOptionsRequest).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotOptionsRequestBuilder {
     pub(crate) allocation_strategy: ::std::option::Option<crate::types::SpotAllocationStrategy>,
     pub(crate) maintenance_strategies: ::std::option::Option<crate::types::FleetSpotMaintenanceStrategiesRequest>,
     pub(crate) instance_interruption_behavior: ::std::option::Option<crate::types::SpotInstanceInterruptionBehavior>,
     pub(crate) instance_pools_to_use_count: ::std::option::Option<i32>,
     pub(crate) single_instance_type: ::std::option::Option<bool>,
     pub(crate) single_availability_zone: ::std::option::Option<bool>,
     pub(crate) min_target_capacity: ::std::option::Option<i32>,
     pub(crate) max_total_price: ::std::option::Option<::std::string::String>,
-349
+}
 impl SpotOptionsRequestBuilder {
     /// <p>The strategy that determines how to allocate the target Spot Instance capacity across the Spot Instance pools specified by the EC2 Fleet launch configuration. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-allocation-strategy.html">Allocation strategies for Spot Instances</a> in the <i>Amazon EC2 User Guide</i>.</p>
     /// <dl>
     /// <dt>
     /// price-capacity-optimized (recommended)
     /// </dt>
     /// <dd>
     /// <p>EC2 Fleet identifies the pools with the highest capacity availability for the number of instances that are launching. This means that we will request Spot Instances from the pools that we believe have the lowest chance of interruption in the near term. EC2 Fleet then requests Spot Instances from the lowest priced of these pools.</p>
     /// </dd>
     /// <dt>

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

@@ -5,5 +145,156 @@

↥ Expand context

 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct SpotPlacement {
     /// <p>The Availability Zone.</p>
     /// <p>\[Spot Fleet only\] To specify multiple Availability Zones, separate them using commas; for example, "us-west-2a, us-west-2b".</p>
     pub availability_zone: ::std::option::Option<::std::string::String>,
     /// <p>The name of the placement group.</p>
     pub group_name: ::std::option::Option<::std::string::String>,
     /// <p>The tenancy of the instance (if the instance is running in a VPC). An instance with a tenancy of <code>dedicated</code> runs on single-tenant hardware. The <code>host</code> tenancy is not supported for Spot Instances.</p>
     pub tenancy: ::std::option::Option<crate::types::Tenancy>,
-14
+}
 impl SpotPlacement {
     /// <p>The Availability Zone.</p>
     /// <p>\[Spot Fleet only\] To specify multiple Availability Zones, separate them using commas; for example, "us-west-2a, us-west-2b".</p>
     pub fn availability_zone(&self) -> ::std::option::Option<&str> {
         self.availability_zone.as_deref()
-20
+    }
     /// <p>The name of the placement group.</p>
     pub fn group_name(&self) -> ::std::option::Option<&str> {
         self.group_name.as_deref()
-24
+    }

     /// <p>The tenancy of the instance (if the instance is running in a VPC). An instance with a tenancy of <code>dedicated</code> runs on single-tenant hardware. The <code>host</code> tenancy is not supported for Spot Instances.</p>
     pub fn tenancy(&self) -> ::std::option::Option<&crate::types::Tenancy> {
         self.tenancy.as_ref()
-28
+    }
-29
+}
 static SPOTPLACEMENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPlacement", "com.amazonaws.ec2", "SpotPlacement");
 static SPOTPLACEMENT_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPlacement$AvailabilityZone", "com.amazonaws.ec2", "SpotPlacement"),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone",
     "AvailabilityZone",
 ,
-37
+)
 .with_xml_name("availabilityZone");
 static SPOTPLACEMENT_MEMBER_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPlacement$GroupName", "com.amazonaws.ec2", "SpotPlacement"),
     ::aws_smithy_schema::ShapeType::String,
     "group_name",
     "GroupName",
 ,
-44
+)
 .with_xml_name("groupName");
 static SPOTPLACEMENT_MEMBER_TENANCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPlacement$Tenancy", "com.amazonaws.ec2", "SpotPlacement"),
     ::aws_smithy_schema::ShapeType::String,
     "tenancy",
     "Tenancy",
 ,
-51
+)
 .with_xml_name("tenancy");
 static SPOTPLACEMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTPLACEMENT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPOTPLACEMENT_MEMBER_AVAILABILITY_ZONE,
         &SPOTPLACEMENT_MEMBER_GROUP_NAME,
         &SPOTPLACEMENT_MEMBER_TENANCY,
     ],
 );
 impl SpotPlacement {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPOTPLACEMENT_SCHEMA;
-65
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SpotPlacement {
     #[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.availability_zone {
             ser.write_string(&SPOTPLACEMENT_MEMBER_AVAILABILITY_ZONE, val)?;
-74
+        }
         if let Some(ref val) = self.group_name {
             ser.write_string(&SPOTPLACEMENT_MEMBER_GROUP_NAME, val)?;
-77
+        }
         if let Some(ref val) = self.tenancy {
             ser.write_string(&SPOTPLACEMENT_MEMBER_TENANCY, val.as_str())?;
-80
+        }
         Ok(())
-82
+    }
-83
+}
 impl SpotPlacement {
     /// 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(&SPOTPLACEMENT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTPLACEMENT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.availability_zone = Some(deser.read_string(member)?);
-102
+                }
                 Some(1) => {
                     builder.group_name = Some(deser.read_string(member)?);
-105
+                }
                 Some(2) => {
                     builder.tenancy = Some(crate::types::Tenancy::from(deser.read_string(member)?.as_str()));
-108
+                }
                 _ => {}
-110
+            }
             Ok(())
         })?;
         Ok(builder.build())
-114
+    }
-115
+}
 impl SpotPlacement {
     /// 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 SpotPlacement {
     /// Creates a new builder-style object to manufacture [`SpotPlacement`](crate::types::SpotPlacement).
     pub fn builder() -> crate::types::builders::SpotPlacementBuilder {
         crate::types::builders::SpotPlacementBuilder::default()
-131
+    }
-132
+}
-133
 /// A builder for [`SpotPlacement`](crate::types::SpotPlacement).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotPlacementBuilder {
     pub(crate) availability_zone: ::std::option::Option<::std::string::String>,
     pub(crate) group_name: ::std::option::Option<::std::string::String>,
     pub(crate) tenancy: ::std::option::Option<crate::types::Tenancy>,
-141
+}
 impl SpotPlacementBuilder {
     /// <p>The Availability Zone.</p>
     /// <p>\[Spot Fleet only\] To specify multiple Availability Zones, separate them using commas; for example, "us-west-2a, us-west-2b".</p>
     pub fn availability_zone(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.availability_zone = ::std::option::Option::Some(input.into());
         self
-148
+    }
     /// <p>The Availability Zone.</p>
     /// <p>\[Spot Fleet only\] To specify multiple Availability Zones, separate them using commas; for example, "us-west-2a, us-west-2b".</p>
     pub fn set_availability_zone(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.availability_zone = input;
         self
-154
+    }
     /// <p>The Availability Zone.</p>
     /// <p>\[Spot Fleet only\] To specify multiple Availability Zones, separate them using commas; for example, "us-west-2a, us-west-2b".</p>

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

@@ -3,3 +147,158 @@

↥ Expand context

 /// <p>The Spot placement score for this Region or Availability Zone. The score is calculated based on the assumption that the <code>capacity-optimized</code> allocation strategy is used and that all of the Availability Zones in the Region can be used.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct SpotPlacementScore {
     /// <p>The Region.</p>
     pub region: ::std::option::Option<::std::string::String>,
     /// <p>The Availability Zone.</p>
     pub availability_zone_id: ::std::option::Option<::std::string::String>,
     /// <p>The placement score, on a scale from <code>1</code> to <code>10</code>. A score of <code>10</code> indicates that your Spot request is highly likely to succeed in this Region or Availability Zone. A score of <code>1</code> indicates that your Spot request is not likely to succeed.</p>
     pub score: ::std::option::Option<i32>,
-13
+}
 impl SpotPlacementScore {
     /// <p>The Region.</p>
     pub fn region(&self) -> ::std::option::Option<&str> {
         self.region.as_deref()
-18
+    }
     /// <p>The Availability Zone.</p>
     pub fn availability_zone_id(&self) -> ::std::option::Option<&str> {
         self.availability_zone_id.as_deref()
-22
+    }

     /// <p>The placement score, on a scale from <code>1</code> to <code>10</code>. A score of <code>10</code> indicates that your Spot request is highly likely to succeed in this Region or Availability Zone. A score of <code>1</code> indicates that your Spot request is not likely to succeed.</p>
     pub fn score(&self) -> ::std::option::Option<i32> {
         self.score
-26
+    }
-27
+}
 static SPOTPLACEMENTSCORE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPlacementScore", "com.amazonaws.ec2", "SpotPlacementScore");
 static SPOTPLACEMENTSCORE_MEMBER_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPlacementScore$Region", "com.amazonaws.ec2", "SpotPlacementScore"),
     ::aws_smithy_schema::ShapeType::String,
     "region",
     "Region",
 ,
-35
+)
 .with_xml_name("region");
 static SPOTPLACEMENTSCORE_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#SpotPlacementScore$AvailabilityZoneId",
         "com.amazonaws.ec2",
         "SpotPlacementScore",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone_id",
     "AvailabilityZoneId",
 ,
-46
+)
 .with_xml_name("availabilityZoneId");
 static SPOTPLACEMENTSCORE_MEMBER_SCORE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPlacementScore$Score", "com.amazonaws.ec2", "SpotPlacementScore"),
     ::aws_smithy_schema::ShapeType::Integer,
     "score",
     "Score",
 ,
-53
+)
 .with_xml_name("score");
 static SPOTPLACEMENTSCORE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTPLACEMENTSCORE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPOTPLACEMENTSCORE_MEMBER_REGION,
         &SPOTPLACEMENTSCORE_MEMBER_AVAILABILITY_ZONE_ID,
         &SPOTPLACEMENTSCORE_MEMBER_SCORE,
     ],
 );
 impl SpotPlacementScore {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPOTPLACEMENTSCORE_SCHEMA;
-67
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SpotPlacementScore {
     #[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.region {
             ser.write_string(&SPOTPLACEMENTSCORE_MEMBER_REGION, val)?;
-76
+        }
         if let Some(ref val) = self.availability_zone_id {
             ser.write_string(&SPOTPLACEMENTSCORE_MEMBER_AVAILABILITY_ZONE_ID, val)?;
-79
+        }
         if let Some(ref val) = self.score {
             ser.write_integer(&SPOTPLACEMENTSCORE_MEMBER_SCORE, *val)?;
-82
+        }
         Ok(())
-84
+    }
-85
+}
 impl SpotPlacementScore {
     /// 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(&SPOTPLACEMENTSCORE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTPLACEMENTSCORE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.region = Some(deser.read_string(member)?);
-104
+                }
                 Some(1) => {
                     builder.availability_zone_id = Some(deser.read_string(member)?);
-107
+                }
                 Some(2) => {
                     builder.score = Some(deser.read_integer(member)?);
-110
+                }
                 _ => {}
-112
+            }
             Ok(())
         })?;
         Ok(builder.build())
-116
+    }
-117
+}
 impl SpotPlacementScore {
     /// 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 SpotPlacementScore {
     /// Creates a new builder-style object to manufacture [`SpotPlacementScore`](crate::types::SpotPlacementScore).
     pub fn builder() -> crate::types::builders::SpotPlacementScoreBuilder {
         crate::types::builders::SpotPlacementScoreBuilder::default()
-133
+    }
-134
+}
-135
 /// A builder for [`SpotPlacementScore`](crate::types::SpotPlacementScore).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotPlacementScoreBuilder {
     pub(crate) region: ::std::option::Option<::std::string::String>,
     pub(crate) availability_zone_id: ::std::option::Option<::std::string::String>,
     pub(crate) score: ::std::option::Option<i32>,
-143
+}
 impl SpotPlacementScoreBuilder {
     /// <p>The Region.</p>
     pub fn region(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.region = ::std::option::Option::Some(input.into());
         self
-149
+    }
     /// <p>The Region.</p>
     pub fn set_region(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.region = input;
         self
-154
+    }
     /// <p>The Region.</p>
     pub fn get_region(&self) -> &::std::option::Option<::std::string::String> {
         &self.region
-158
+    }

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

@@ -27,27 +209,220 @@

↥ Expand context

         self.availability_zone.as_deref()
-28
+    }
     /// <p>The ID of the Availability Zone.</p>
     pub fn availability_zone_id(&self) -> ::std::option::Option<&str> {
         self.availability_zone_id.as_deref()
-32
+    }
     /// <p>The instance type.</p>
     pub fn instance_type(&self) -> ::std::option::Option<&crate::types::InstanceType> {
         self.instance_type.as_ref()
-36
+    }
     /// <p>A general description of the AMI.</p>
     pub fn product_description(&self) -> ::std::option::Option<&crate::types::RiProductDescription> {
         self.product_description.as_ref()
-40
+    }
     /// <p>The maximum price per unit hour that you are willing to pay for a Spot Instance. We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price.</p><important>
     /// <p>If you specify a maximum price, your instances will be interrupted more frequently than if you do not specify this parameter.</p>
     /// </important>
     pub fn spot_price(&self) -> ::std::option::Option<&str> {
         self.spot_price.as_deref()
-46
+    }

     /// <p>The date and time the request was created, in UTC format (for example, <i>YYYY</i>-<i>MM</i>-<i>DD</i>T<i>HH</i>:<i>MM</i>:<i>SS</i>Z).</p>
     pub fn timestamp(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.timestamp.as_ref()
-50
+    }
-51
+}
 static SPOTPRICE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPrice", "com.amazonaws.ec2", "SpotPrice");
 static SPOTPRICE_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPrice$AvailabilityZone", "com.amazonaws.ec2", "SpotPrice"),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone",
     "AvailabilityZone",
 ,
-59
+)
 .with_xml_name("availabilityZone");
 static SPOTPRICE_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPrice$AvailabilityZoneId", "com.amazonaws.ec2", "SpotPrice"),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone_id",
     "AvailabilityZoneId",
 ,
-66
+)
 .with_xml_name("availabilityZoneId");
 static SPOTPRICE_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPrice$InstanceType", "com.amazonaws.ec2", "SpotPrice"),
     ::aws_smithy_schema::ShapeType::String,
     "instance_type",
     "InstanceType",
 ,
-73
+)
 .with_xml_name("instanceType");
 static SPOTPRICE_MEMBER_PRODUCT_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPrice$ProductDescription", "com.amazonaws.ec2", "SpotPrice"),
     ::aws_smithy_schema::ShapeType::String,
     "product_description",
     "ProductDescription",
 ,
-80
+)
 .with_xml_name("productDescription");
 static SPOTPRICE_MEMBER_SPOT_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPrice$SpotPrice", "com.amazonaws.ec2", "SpotPrice"),
     ::aws_smithy_schema::ShapeType::String,
     "spot_price",
     "SpotPrice",
 ,
-87
+)
 .with_xml_name("spotPrice");
 static SPOTPRICE_MEMBER_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SpotPrice$Timestamp", "com.amazonaws.ec2", "SpotPrice"),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "timestamp",
     "Timestamp",
 ,
-94
+)
 .with_xml_name("timestamp");
 static SPOTPRICE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPOTPRICE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPOTPRICE_MEMBER_AVAILABILITY_ZONE,
         &SPOTPRICE_MEMBER_AVAILABILITY_ZONE_ID,
         &SPOTPRICE_MEMBER_INSTANCE_TYPE,
         &SPOTPRICE_MEMBER_PRODUCT_DESCRIPTION,
         &SPOTPRICE_MEMBER_SPOT_PRICE,
         &SPOTPRICE_MEMBER_TIMESTAMP,
     ],
 );
 impl SpotPrice {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPOTPRICE_SCHEMA;
-111
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SpotPrice {
     #[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.availability_zone {
             ser.write_string(&SPOTPRICE_MEMBER_AVAILABILITY_ZONE, val)?;
-120
+        }
         if let Some(ref val) = self.availability_zone_id {
             ser.write_string(&SPOTPRICE_MEMBER_AVAILABILITY_ZONE_ID, val)?;
-123
+        }
         if let Some(ref val) = self.instance_type {
             ser.write_string(&SPOTPRICE_MEMBER_INSTANCE_TYPE, val.as_str())?;
-126
+        }
         if let Some(ref val) = self.product_description {
             ser.write_string(&SPOTPRICE_MEMBER_PRODUCT_DESCRIPTION, val.as_str())?;
-129
+        }
         if let Some(ref val) = self.spot_price {
             ser.write_string(&SPOTPRICE_MEMBER_SPOT_PRICE, val)?;
-132
+        }
         if let Some(ref val) = self.timestamp {
             ser.write_timestamp(&SPOTPRICE_MEMBER_TIMESTAMP, val)?;
-135
+        }
         Ok(())
-137
+    }
-138
+}
 impl SpotPrice {
     /// 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(&SPOTPRICE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPOTPRICE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.availability_zone = Some(deser.read_string(member)?);
-157
+                }
                 Some(1) => {
                     builder.availability_zone_id = Some(deser.read_string(member)?);
-160
+                }
                 Some(2) => {
                     builder.instance_type = Some(crate::types::InstanceType::from(deser.read_string(member)?.as_str()));
-163
+                }
                 Some(3) => {
                     builder.product_description = Some(crate::types::RiProductDescription::from(deser.read_string(member)?.as_str()));
-166
+                }
                 Some(4) => {
                     builder.spot_price = Some(deser.read_string(member)?);
-169
+                }
                 Some(5) => {
                     builder.timestamp = Some(deser.read_timestamp(member)?);
-172
+                }
                 _ => {}
-174
+            }
             Ok(())
         })?;
         Ok(builder.build())
-178
+    }
-179
+}
 impl SpotPrice {
     /// 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 SpotPrice {
     /// Creates a new builder-style object to manufacture [`SpotPrice`](crate::types::SpotPrice).
     pub fn builder() -> crate::types::builders::SpotPriceBuilder {
         crate::types::builders::SpotPriceBuilder::default()
-195
+    }
-196
+}
-197
 /// A builder for [`SpotPrice`](crate::types::SpotPrice).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SpotPriceBuilder {
     pub(crate) availability_zone: ::std::option::Option<::std::string::String>,
     pub(crate) availability_zone_id: ::std::option::Option<::std::string::String>,
     pub(crate) instance_type: ::std::option::Option<crate::types::InstanceType>,
     pub(crate) product_description: ::std::option::Option<crate::types::RiProductDescription>,
     pub(crate) spot_price: ::std::option::Option<::std::string::String>,
     pub(crate) timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
-208
+}
 impl SpotPriceBuilder {
     /// <p>The Availability Zone.</p>
     pub fn availability_zone(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.availability_zone = ::std::option::Option::Some(input.into());
         self
-214
+    }
     /// <p>The Availability Zone.</p>
     pub fn set_availability_zone(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.availability_zone = input;
         self
-219
+    }
     /// <p>The Availability Zone.</p>

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

@@ -27,27 +130,130 @@

↥ Expand context

         self.ip_protocol.as_deref()
-28
+    }
     /// <p>The IP ranges. Not applicable for stale security group rules.</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 `.ip_ranges.is_none()`.
     pub fn ip_ranges(&self) -> &[::std::string::String] {
         self.ip_ranges.as_deref().unwrap_or_default()
-34
+    }
     /// <p>The prefix list IDs. Not applicable for stale security group rules.</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 `.prefix_list_ids.is_none()`.
     pub fn prefix_list_ids(&self) -> &[::std::string::String] {
         self.prefix_list_ids.as_deref().unwrap_or_default()
-40
+    }
     /// <p>If the protocol is TCP or UDP, this is the end of the port range. If the protocol is ICMP or ICMPv6, this is the ICMP code or -1 (all ICMP codes).</p>
     pub fn to_port(&self) -> ::std::option::Option<i32> {
         self.to_port
-44
+    }
     /// <p>The security group pairs. Returns the ID of the referenced security group and VPC, and the ID and status of the VPC peering connection.</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 `.user_id_group_pairs.is_none()`.
     pub fn user_id_group_pairs(&self) -> &[crate::types::UserIdGroupPair] {
         self.user_id_group_pairs.as_deref().unwrap_or_default()
-50
+    }
-51
+}
 static STALEIPPERMISSION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#StaleIpPermission", "com.amazonaws.ec2", "StaleIpPermission");
 static STALEIPPERMISSION_MEMBER_FROM_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#StaleIpPermission$FromPort", "com.amazonaws.ec2", "StaleIpPermission"),
     ::aws_smithy_schema::ShapeType::Integer,
     "from_port",
     "FromPort",
 ,
-59
+)
 .with_xml_name("fromPort");
 static STALEIPPERMISSION_MEMBER_IP_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#StaleIpPermission$IpProtocol", "com.amazonaws.ec2", "StaleIpPermission"),
     ::aws_smithy_schema::ShapeType::String,
     "ip_protocol",
     "IpProtocol",
 ,
-66
+)
 .with_xml_name("ipProtocol");
 static STALEIPPERMISSION_MEMBER_IP_RANGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#StaleIpPermission$IpRanges", "com.amazonaws.ec2", "StaleIpPermission"),
     ::aws_smithy_schema::ShapeType::List,
     "ip_ranges",
     "IpRanges",
 ,
-73
+)
 .with_xml_name("ipRanges");
 static STALEIPPERMISSION_MEMBER_PREFIX_LIST_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#StaleIpPermission$PrefixListIds",
         "com.amazonaws.ec2",
         "StaleIpPermission",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "prefix_list_ids",
     "PrefixListIds",
 ,
-84
+)
 .with_xml_name("prefixListIds");
 static STALEIPPERMISSION_MEMBER_TO_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#StaleIpPermission$ToPort", "com.amazonaws.ec2", "StaleIpPermission"),
     ::aws_smithy_schema::ShapeType::Integer,
     "to_port",
     "ToPort",
 ,
-91
+)
 .with_xml_name("toPort");
 static STALEIPPERMISSION_MEMBER_USER_ID_GROUP_PAIRS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#StaleIpPermission$UserIdGroupPairs",
         "com.amazonaws.ec2",
         "StaleIpPermission",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "user_id_group_pairs",
     "UserIdGroupPairs",
 ,
-102
+)
 .with_xml_name("groups");
 static STALEIPPERMISSION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STALEIPPERMISSION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STALEIPPERMISSION_MEMBER_FROM_PORT,
         &STALEIPPERMISSION_MEMBER_IP_PROTOCOL,
         &STALEIPPERMISSION_MEMBER_IP_RANGES,

↧ Expand context

         &STALEIPPERMISSION_MEMBER_PREFIX_LIST_IDS,
         &STALEIPPERMISSION_MEMBER_TO_PORT,
         &STALEIPPERMISSION_MEMBER_USER_ID_GROUP_PAIRS,
     ],
 );
 impl StaleIpPermission {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STALEIPPERMISSION_SCHEMA;
-119
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StaleIpPermission {
     #[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.from_port {
             ser.write_integer(&STALEIPPERMISSION_MEMBER_FROM_PORT, *val)?;
-128
+        }
         if let Some(ref val) = self.ip_protocol {
             ser.write_string(&STALEIPPERMISSION_MEMBER_IP_PROTOCOL, val)?;

@@ -143,143 +271,259 @@

↥ Expand context

         if let Some(ref val) = self.prefix_list_ids {
             ser.write_list(
                 &STALEIPPERMISSION_MEMBER_PREFIX_LIST_IDS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-149
+                    }
                     Ok(())
                 },
             )?;
-153
+        }
         if let Some(ref val) = self.to_port {
             ser.write_integer(&STALEIPPERMISSION_MEMBER_TO_PORT, *val)?;
-156
+        }
         if let Some(ref val) = self.user_id_group_pairs {
             ser.write_list(
                 &STALEIPPERMISSION_MEMBER_USER_ID_GROUP_PAIRS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::UserIdGroupPair::SCHEMA, item)?;

-163
+                    }
                     Ok(())
                 },
             )?;
-167
+        }
         Ok(())
-169
+    }
-170
+}
 impl StaleIpPermission {
     /// 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(&STALEIPPERMISSION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STALEIPPERMISSION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.from_port = Some(deser.read_integer(member)?);
-189
+                }
                 Some(1) => {
                     builder.ip_protocol = Some(deser.read_string(member)?);
-192
+                }
                 Some(2) => {
                     builder.ip_ranges = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.ip_ranges = Some(deser.read_string_list(member)?);
-195
+                }
                 Some(3) => {
                     builder.prefix_list_ids = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.prefix_list_ids = Some(deser.read_string_list(member)?);
-198
+                }
                 Some(4) => {
                     builder.to_port = Some(deser.read_integer(member)?);
-201
+                }
                 Some(5) => {
                     builder.user_id_group_pairs = 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::UserIdGroupPair::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::UserIdGroupPair::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-211
+                }
                 _ => {}
-213
+            }
             Ok(())
         })?;
         Ok(builder.build())
-217
+    }
-218
+}
 impl StaleIpPermission {
     /// 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 StaleIpPermission {
     /// Creates a new builder-style object to manufacture [`StaleIpPermission`](crate::types::StaleIpPermission).
     pub fn builder() -> crate::types::builders::StaleIpPermissionBuilder {
         crate::types::builders::StaleIpPermissionBuilder::default()
-234
+    }
-235
+}
-236
 /// A builder for [`StaleIpPermission`](crate::types::StaleIpPermission).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct StaleIpPermissionBuilder {
     pub(crate) from_port: ::std::option::Option<i32>,
     pub(crate) ip_protocol: ::std::option::Option<::std::string::String>,
     pub(crate) ip_ranges: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) prefix_list_ids: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) to_port: ::std::option::Option<i32>,
     pub(crate) user_id_group_pairs: ::std::option::Option<::std::vec::Vec<crate::types::UserIdGroupPair>>,
-247
+}
 impl StaleIpPermissionBuilder {
     /// <p>If the protocol is TCP or UDP, this is the start of the port range. If the protocol is ICMP or ICMPv6, this is the ICMP type or -1 (all ICMP types).</p>
     pub fn from_port(mut self, input: i32) -> Self {
         self.from_port = ::std::option::Option::Some(input);
         self
-253
+    }
     /// <p>If the protocol is TCP or UDP, this is the start of the port range. If the protocol is ICMP or ICMPv6, this is the ICMP type or -1 (all ICMP types).</p>
     pub fn set_from_port(mut self, input: ::std::option::Option<i32>) -> Self {
         self.from_port = input;
         self
-258
+    }
     /// <p>If the protocol is TCP or UDP, this is the start of the port range. If the protocol is ICMP or ICMPv6, this is the ICMP type or -1 (all ICMP types).</p>

AWS SDK

Files changed: