AWS SDK

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

@@ -45,45 +162,162 @@

         self.route_status.as_ref()
-46
+    }
     /// <p>The destination CIDR block of the route.</p>
     pub fn prefix(&self) -> ::std::option::Option<&str> {
         self.prefix.as_deref()
-50
+    }
     /// <p>The AS path attributes of the BGP route.</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 `.as_paths.is_none()`.
     pub fn as_paths(&self) -> &[::std::string::String] {
         self.as_paths.as_deref().unwrap_or_default()
-56
+    }
     /// <p>The Multi-Exit Discriminator (MED) value of the BGP route.</p>
     pub fn med(&self) -> ::std::option::Option<i32> {
         self.med
-60
+    }
     /// <p>The IP address for the next hop.</p>
     pub fn next_hop_ip(&self) -> ::std::option::Option<&str> {
         self.next_hop_ip.as_deref()
-64
+    }

-65
+}
 static ROUTESERVERROUTE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerRoute", "com.amazonaws.ec2", "RouteServerRoute");
 static ROUTESERVERROUTE_MEMBER_ROUTE_SERVER_ENDPOINT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteServerRoute$RouteServerEndpointId",
         "com.amazonaws.ec2",
         "RouteServerRoute",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "route_server_endpoint_id",
     "RouteServerEndpointId",
 ,
-77
+)
 .with_xml_name("routeServerEndpointId");
 static ROUTESERVERROUTE_MEMBER_ROUTE_SERVER_PEER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteServerRoute$RouteServerPeerId",
         "com.amazonaws.ec2",
         "RouteServerRoute",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "route_server_peer_id",
     "RouteServerPeerId",
 ,
-88
+)
 .with_xml_name("routeServerPeerId");
 static ROUTESERVERROUTE_MEMBER_ROUTE_INSTALLATION_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteServerRoute$RouteInstallationDetails",
         "com.amazonaws.ec2",
         "RouteServerRoute",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "route_installation_details",
     "RouteInstallationDetails",
 ,
-99
+)
 .with_xml_name("routeInstallationDetailSet");
 static ROUTESERVERROUTE_MEMBER_ROUTE_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerRoute$RouteStatus", "com.amazonaws.ec2", "RouteServerRoute"),
     ::aws_smithy_schema::ShapeType::String,
     "route_status",
     "RouteStatus",
 ,
-106
+)
 .with_xml_name("routeStatus");
 static ROUTESERVERROUTE_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerRoute$Prefix", "com.amazonaws.ec2", "RouteServerRoute"),
     ::aws_smithy_schema::ShapeType::String,
     "prefix",
     "Prefix",
 ,
-113
+)
 .with_xml_name("prefix");
 static ROUTESERVERROUTE_MEMBER_AS_PATHS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerRoute$AsPaths", "com.amazonaws.ec2", "RouteServerRoute"),
     ::aws_smithy_schema::ShapeType::List,
     "as_paths",
     "AsPaths",
 ,
-120
+)
 .with_xml_name("asPathSet");
 static ROUTESERVERROUTE_MEMBER_MED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerRoute$Med", "com.amazonaws.ec2", "RouteServerRoute"),
     ::aws_smithy_schema::ShapeType::Integer,
     "med",
     "Med",
 ,
-127
+)
 .with_xml_name("med");
 static ROUTESERVERROUTE_MEMBER_NEXT_HOP_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerRoute$NextHopIp", "com.amazonaws.ec2", "RouteServerRoute"),
     ::aws_smithy_schema::ShapeType::String,
     "next_hop_ip",
     "NextHopIp",
 ,
-134
+)
 .with_xml_name("nextHopIp");
 static ROUTESERVERROUTE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ROUTESERVERROUTE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &ROUTESERVERROUTE_MEMBER_ROUTE_SERVER_ENDPOINT_ID,
         &ROUTESERVERROUTE_MEMBER_ROUTE_SERVER_PEER_ID,
         &ROUTESERVERROUTE_MEMBER_ROUTE_INSTALLATION_DETAILS,

↧ Expand context

         &ROUTESERVERROUTE_MEMBER_ROUTE_STATUS,
         &ROUTESERVERROUTE_MEMBER_PREFIX,
         &ROUTESERVERROUTE_MEMBER_AS_PATHS,
         &ROUTESERVERROUTE_MEMBER_MED,
         &ROUTESERVERROUTE_MEMBER_NEXT_HOP_IP,
     ],
 );
 impl RouteServerRoute {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ROUTESERVERROUTE_SCHEMA;
-153
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RouteServerRoute {
     #[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.route_server_endpoint_id {
             ser.write_string(&ROUTESERVERROUTE_MEMBER_ROUTE_SERVER_ENDPOINT_ID, val)?;
-162
+        }

@@ -175,175 +299,297 @@

↥ Expand context

             )?;
-176
+        }
         if let Some(ref val) = self.route_status {
             ser.write_string(&ROUTESERVERROUTE_MEMBER_ROUTE_STATUS, val.as_str())?;
-179
+        }
         if let Some(ref val) = self.prefix {
             ser.write_string(&ROUTESERVERROUTE_MEMBER_PREFIX, val)?;
-182
+        }
         if let Some(ref val) = self.as_paths {
             ser.write_list(
                 &ROUTESERVERROUTE_MEMBER_AS_PATHS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-189
+                    }
                     Ok(())
                 },
             )?;
-193
+        }
         if let Some(ref val) = self.med {

             ser.write_integer(&ROUTESERVERROUTE_MEMBER_MED, *val)?;
-196
+        }
         if let Some(ref val) = self.next_hop_ip {
             ser.write_string(&ROUTESERVERROUTE_MEMBER_NEXT_HOP_IP, val)?;
-199
+        }
         Ok(())
-201
+    }
-202
+}
 impl RouteServerRoute {
     /// 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(&ROUTESERVERROUTE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ROUTESERVERROUTE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.route_server_endpoint_id = Some(deser.read_string(member)?);
-221
+                }
                 Some(1) => {
                     builder.route_server_peer_id = Some(deser.read_string(member)?);
-224
+                }
                 Some(2) => {
                     builder.route_installation_details = 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::RouteServerRouteInstallationDetail::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::RouteServerRouteInstallationDetail::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-234
+                }
                 Some(3) => {
                     builder.route_status = Some(crate::types::RouteServerRouteStatus::from(deser.read_string(member)?.as_str()));
-237
+                }
                 Some(4) => {
                     builder.prefix = Some(deser.read_string(member)?);
-240
+                }
                 Some(5) => {
                     builder.as_paths = 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.as_paths = Some(deser.read_string_list(member)?);
-243
+                }
                 Some(6) => {
                     builder.med = Some(deser.read_integer(member)?);
-246
+                }
                 Some(7) => {
                     builder.next_hop_ip = Some(deser.read_string(member)?);
-249
+                }
                 _ => {}
-251
+            }
             Ok(())
         })?;
         Ok(builder.build())
-255
+    }
-256
+}
 impl RouteServerRoute {
     /// 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 RouteServerRoute {
     /// Creates a new builder-style object to manufacture [`RouteServerRoute`](crate::types::RouteServerRoute).
     pub fn builder() -> crate::types::builders::RouteServerRouteBuilder {
         crate::types::builders::RouteServerRouteBuilder::default()
-272
+    }
-273
+}
-274
 /// A builder for [`RouteServerRoute`](crate::types::RouteServerRoute).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RouteServerRouteBuilder {
     pub(crate) route_server_endpoint_id: ::std::option::Option<::std::string::String>,
     pub(crate) route_server_peer_id: ::std::option::Option<::std::string::String>,
     pub(crate) route_installation_details: ::std::option::Option<::std::vec::Vec<crate::types::RouteServerRouteInstallationDetail>>,
     pub(crate) route_status: ::std::option::Option<crate::types::RouteServerRouteStatus>,
     pub(crate) prefix: ::std::option::Option<::std::string::String>,
     pub(crate) as_paths: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) med: ::std::option::Option<i32>,
     pub(crate) next_hop_ip: ::std::option::Option<::std::string::String>,
-287
+}
 impl RouteServerRouteBuilder {
     /// <p>The ID of the route server endpoint that received this route.</p>
     pub fn route_server_endpoint_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.route_server_endpoint_id = ::std::option::Option::Some(input.into());
         self
-293
+    }
     /// <p>The ID of the route server endpoint that received this route.</p>
     pub fn set_route_server_endpoint_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.route_server_endpoint_id = input;
         self

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

@@ -10,10 +161,172 @@

↥ Expand context

     pub route_installation_status: ::std::option::Option<crate::types::RouteServerRouteInstallationStatus>,
     /// <p>The reason for the current installation status of the route.</p>
     pub route_installation_status_reason: ::std::option::Option<::std::string::String>,
-13
+}
 impl RouteServerRouteInstallationDetail {
     /// <p>The ID of the route table where the route is being installed.</p>
     pub fn route_table_id(&self) -> ::std::option::Option<&str> {
         self.route_table_id.as_deref()
-18
+    }
     /// <p>The current installation status of the route in the route table.</p>
     pub fn route_installation_status(&self) -> ::std::option::Option<&crate::types::RouteServerRouteInstallationStatus> {
         self.route_installation_status.as_ref()
-22
+    }
     /// <p>The reason for the current installation status of the route.</p>
     pub fn route_installation_status_reason(&self) -> ::std::option::Option<&str> {
         self.route_installation_status_reason.as_deref()
-26
+    }
-27
+}
 static ROUTESERVERROUTEINSTALLATIONDETAIL_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#RouteServerRouteInstallationDetail",

     "com.amazonaws.ec2",
     "RouteServerRouteInstallationDetail",
 );
 static ROUTESERVERROUTEINSTALLATIONDETAIL_MEMBER_ROUTE_TABLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteServerRouteInstallationDetail$RouteTableId",
         "com.amazonaws.ec2",
         "RouteServerRouteInstallationDetail",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "route_table_id",
     "RouteTableId",
 ,
-42
+)
 .with_xml_name("routeTableId");
 static ROUTESERVERROUTEINSTALLATIONDETAIL_MEMBER_ROUTE_INSTALLATION_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteServerRouteInstallationDetail$RouteInstallationStatus",
         "com.amazonaws.ec2",
         "RouteServerRouteInstallationDetail",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "route_installation_status",
     "RouteInstallationStatus",
 ,
-53
+)
 .with_xml_name("routeInstallationStatus");
 static ROUTESERVERROUTEINSTALLATIONDETAIL_MEMBER_ROUTE_INSTALLATION_STATUS_REASON: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2#RouteServerRouteInstallationDetail$RouteInstallationStatusReason",
             "com.amazonaws.ec2",
             "RouteServerRouteInstallationDetail",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "route_installation_status_reason",
         "RouteInstallationStatusReason",
 ,
-65
+    )
     .with_xml_name("routeInstallationStatusReason");
 static ROUTESERVERROUTEINSTALLATIONDETAIL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ROUTESERVERROUTEINSTALLATIONDETAIL_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &ROUTESERVERROUTEINSTALLATIONDETAIL_MEMBER_ROUTE_TABLE_ID,
         &ROUTESERVERROUTEINSTALLATIONDETAIL_MEMBER_ROUTE_INSTALLATION_STATUS,
         &ROUTESERVERROUTEINSTALLATIONDETAIL_MEMBER_ROUTE_INSTALLATION_STATUS_REASON,
     ],
 );
 impl RouteServerRouteInstallationDetail {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ROUTESERVERROUTEINSTALLATIONDETAIL_SCHEMA;
-79
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RouteServerRouteInstallationDetail {
     #[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.route_table_id {
             ser.write_string(&ROUTESERVERROUTEINSTALLATIONDETAIL_MEMBER_ROUTE_TABLE_ID, val)?;
-88
+        }
         if let Some(ref val) = self.route_installation_status {
             ser.write_string(&ROUTESERVERROUTEINSTALLATIONDETAIL_MEMBER_ROUTE_INSTALLATION_STATUS, val.as_str())?;
-91
+        }
         if let Some(ref val) = self.route_installation_status_reason {
             ser.write_string(&ROUTESERVERROUTEINSTALLATIONDETAIL_MEMBER_ROUTE_INSTALLATION_STATUS_REASON, val)?;
-94
+        }
         Ok(())
-96
+    }
-97
+}
 impl RouteServerRouteInstallationDetail {
     /// 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(&ROUTESERVERROUTEINSTALLATIONDETAIL_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ROUTESERVERROUTEINSTALLATIONDETAIL_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.route_table_id = Some(deser.read_string(member)?);
-116
+                }
                 Some(1) => {
                     builder.route_installation_status = Some(crate::types::RouteServerRouteInstallationStatus::from(
                         deser.read_string(member)?.as_str(),
                     ));
-121
+                }
                 Some(2) => {
                     builder.route_installation_status_reason = Some(deser.read_string(member)?);
-124
+                }
                 _ => {}
-126
+            }
             Ok(())
         })?;
         Ok(builder.build())
-130
+    }
-131
+}
 impl RouteServerRouteInstallationDetail {
     /// 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 RouteServerRouteInstallationDetail {
     /// Creates a new builder-style object to manufacture [`RouteServerRouteInstallationDetail`](crate::types::RouteServerRouteInstallationDetail).
     pub fn builder() -> crate::types::builders::RouteServerRouteInstallationDetailBuilder {
         crate::types::builders::RouteServerRouteInstallationDetailBuilder::default()
-147
+    }
-148
+}
-149
 /// A builder for [`RouteServerRouteInstallationDetail`](crate::types::RouteServerRouteInstallationDetail).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RouteServerRouteInstallationDetailBuilder {
     pub(crate) route_table_id: ::std::option::Option<::std::string::String>,
     pub(crate) route_installation_status: ::std::option::Option<crate::types::RouteServerRouteInstallationStatus>,
     pub(crate) route_installation_status_reason: ::std::option::Option<::std::string::String>,
-157
+}
 impl RouteServerRouteInstallationDetailBuilder {
     /// <p>The ID of the route table where the route is being installed.</p>
     pub fn route_table_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.route_table_id = ::std::option::Option::Some(input.into());
         self
-163
+    }
     /// <p>The ID of the route table where the route is being installed.</p>
     pub fn set_route_table_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.route_table_id = input;
         self
-168
+    }
     /// <p>The ID of the route table where the route is being installed.</p>
     pub fn get_route_table_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.route_table_id
-172
+    }

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

@@ -35,35 +137,137 @@

↥ Expand context

     /// <p>The ID of the route table.</p>
     pub fn route_table_id(&self) -> ::std::option::Option<&str> {
         self.route_table_id.as_deref()
-38
+    }
     /// <p>The routes in the route table.</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 `.routes.is_none()`.
     pub fn routes(&self) -> &[crate::types::Route] {
         self.routes.as_deref().unwrap_or_default()
-44
+    }
     /// <p>Any tags assigned to the route table.</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()
-50
+    }
     /// <p>The ID of the VPC.</p>
     pub fn vpc_id(&self) -> ::std::option::Option<&str> {
         self.vpc_id.as_deref()
-54
+    }

     /// <p>The ID of the Amazon Web Services account that owns the route table.</p>
     pub fn owner_id(&self) -> ::std::option::Option<&str> {
         self.owner_id.as_deref()
-58
+    }
-59
+}
 static ROUTETABLE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteTable", "com.amazonaws.ec2", "RouteTable");
 static ROUTETABLE_MEMBER_ASSOCIATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteTable$Associations", "com.amazonaws.ec2", "RouteTable"),
     ::aws_smithy_schema::ShapeType::List,
     "associations",
     "Associations",
 ,
-67
+)
 .with_xml_name("associationSet");
 static ROUTETABLE_MEMBER_PROPAGATING_VGWS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteTable$PropagatingVgws", "com.amazonaws.ec2", "RouteTable"),
     ::aws_smithy_schema::ShapeType::List,
     "propagating_vgws",
     "PropagatingVgws",
 ,
-74
+)
 .with_xml_name("propagatingVgwSet");
 static ROUTETABLE_MEMBER_ROUTE_TABLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteTable$RouteTableId", "com.amazonaws.ec2", "RouteTable"),
     ::aws_smithy_schema::ShapeType::String,
     "route_table_id",
     "RouteTableId",
 ,
-81
+)
 .with_xml_name("routeTableId");
 static ROUTETABLE_MEMBER_ROUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteTable$Routes", "com.amazonaws.ec2", "RouteTable"),
     ::aws_smithy_schema::ShapeType::List,
     "routes",
     "Routes",
 ,
-88
+)
 .with_xml_name("routeSet");
 static ROUTETABLE_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteTable$Tags", "com.amazonaws.ec2", "RouteTable"),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-95
+)
 .with_xml_name("tagSet");
 static ROUTETABLE_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteTable$VpcId", "com.amazonaws.ec2", "RouteTable"),
     ::aws_smithy_schema::ShapeType::String,
     "vpc_id",
     "VpcId",
 ,
-102
+)
 .with_xml_name("vpcId");
 static ROUTETABLE_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteTable$OwnerId", "com.amazonaws.ec2", "RouteTable"),
     ::aws_smithy_schema::ShapeType::String,
     "owner_id",
     "OwnerId",
 ,
-109
+)
 .with_xml_name("ownerId");
 static ROUTETABLE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ROUTETABLE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &ROUTETABLE_MEMBER_ASSOCIATIONS,
         &ROUTETABLE_MEMBER_PROPAGATING_VGWS,
         &ROUTETABLE_MEMBER_ROUTE_TABLE_ID,

↧ Expand context

         &ROUTETABLE_MEMBER_ROUTES,
         &ROUTETABLE_MEMBER_TAGS,
         &ROUTETABLE_MEMBER_VPC_ID,
         &ROUTETABLE_MEMBER_OWNER_ID,
     ],
 );
 impl RouteTable {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ROUTETABLE_SCHEMA;
-127
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RouteTable {
     #[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.associations {
             ser.write_list(
                 &ROUTETABLE_MEMBER_ASSOCIATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {

@@ -156,156 +297,296 @@

↥ Expand context

         if let Some(ref val) = self.route_table_id {
             ser.write_string(&ROUTETABLE_MEMBER_ROUTE_TABLE_ID, val)?;
-158
+        }
         if let Some(ref val) = self.routes {
             ser.write_list(&ROUTETABLE_MEMBER_ROUTES, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                 for item in val {
                     ser.write_struct(crate::types::Route::SCHEMA, item)?;
-163
+                }
                 Ok(())
             })?;
-166
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(&ROUTETABLE_MEMBER_TAGS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                 for item in val {
                     ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-171
+                }
                 Ok(())
             })?;
-174
+        }
         if let Some(ref val) = self.vpc_id {

             ser.write_string(&ROUTETABLE_MEMBER_VPC_ID, val)?;
-177
+        }
         if let Some(ref val) = self.owner_id {
             ser.write_string(&ROUTETABLE_MEMBER_OWNER_ID, val)?;
-180
+        }
         Ok(())
-182
+    }
-183
+}
 impl RouteTable {
     /// 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(&ROUTETABLE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ROUTETABLE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.associations = 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::RouteTableAssociation::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::RouteTableAssociation::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-209
+                }
                 Some(1) => {
                     builder.propagating_vgws = 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::PropagatingVgw::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::PropagatingVgw::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-219
+                }
                 Some(2) => {
                     builder.route_table_id = Some(deser.read_string(member)?);
-222
+                }
                 Some(3) => {
                     builder.routes = 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::Route::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Route::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-232
+                }
                 Some(4) => {
                     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
                     });
-242
+                }
                 Some(5) => {
                     builder.vpc_id = Some(deser.read_string(member)?);
-245
+                }
                 Some(6) => {
                     builder.owner_id = Some(deser.read_string(member)?);
-248
+                }
                 _ => {}
-250
+            }
             Ok(())
         })?;
         Ok(builder.build())
-254
+    }
-255
+}
 impl RouteTable {
     /// 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 RouteTable {
     /// Creates a new builder-style object to manufacture [`RouteTable`](crate::types::RouteTable).
     pub fn builder() -> crate::types::builders::RouteTableBuilder {
         crate::types::builders::RouteTableBuilder::default()
-271
+    }
-272
+}
-273
 /// A builder for [`RouteTable`](crate::types::RouteTable).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RouteTableBuilder {
     pub(crate) associations: ::std::option::Option<::std::vec::Vec<crate::types::RouteTableAssociation>>,
     pub(crate) propagating_vgws: ::std::option::Option<::std::vec::Vec<crate::types::PropagatingVgw>>,
     pub(crate) route_table_id: ::std::option::Option<::std::string::String>,
     pub(crate) routes: ::std::option::Option<::std::vec::Vec<crate::types::Route>>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) vpc_id: ::std::option::Option<::std::string::String>,
     pub(crate) owner_id: ::std::option::Option<::std::string::String>,
-285
+}
 impl RouteTableBuilder {
     /// Appends an item to `associations`.
     ///
     /// To override the contents of this collection use [`set_associations`](Self::set_associations).
     ///
     /// <p>The associations between the route table and your subnets or gateways.</p>
     pub fn associations(mut self, input: crate::types::RouteTableAssociation) -> Self {
         let mut v = self.associations.unwrap_or_default();
         v.push(input);
         self.associations = ::std::option::Option::Some(v);
         self

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

@@ -31,31 +251,262 @@

↥ Expand context

     /// <p>The ID of the route table.</p>
     pub fn route_table_id(&self) -> ::std::option::Option<&str> {
         self.route_table_id.as_deref()
-34
+    }
     /// <p>The ID of the subnet. A subnet ID is not returned for an implicit association.</p>
     pub fn subnet_id(&self) -> ::std::option::Option<&str> {
         self.subnet_id.as_deref()
-38
+    }
     /// <p>The ID of the internet gateway or virtual private gateway.</p>
     pub fn gateway_id(&self) -> ::std::option::Option<&str> {
         self.gateway_id.as_deref()
-42
+    }
     /// <p>The ID of a public IPv4 pool. A public IPv4 pool is a pool of IPv4 addresses that you've brought to Amazon Web Services with BYOIP.</p>
     pub fn public_ipv4_pool(&self) -> ::std::option::Option<&str> {
         self.public_ipv4_pool.as_deref()
-46
+    }
     /// <p>The state of the association.</p>
     pub fn association_state(&self) -> ::std::option::Option<&crate::types::RouteTableAssociationState> {
         self.association_state.as_ref()
-50
+    }

-51
+}
 static ROUTETABLEASSOCIATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteTableAssociation", "com.amazonaws.ec2", "RouteTableAssociation");
 static ROUTETABLEASSOCIATION_MEMBER_MAIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteTableAssociation$Main",
         "com.amazonaws.ec2",
         "RouteTableAssociation",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "main",
     "Main",
 ,
-63
+)
 .with_xml_name("main");
 static ROUTETABLEASSOCIATION_MEMBER_ROUTE_TABLE_ASSOCIATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteTableAssociation$RouteTableAssociationId",
         "com.amazonaws.ec2",
         "RouteTableAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "route_table_association_id",
     "RouteTableAssociationId",
 ,
-74
+)
 .with_xml_name("routeTableAssociationId");
 static ROUTETABLEASSOCIATION_MEMBER_ROUTE_TABLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteTableAssociation$RouteTableId",
         "com.amazonaws.ec2",
         "RouteTableAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "route_table_id",
     "RouteTableId",
 ,
-85
+)
 .with_xml_name("routeTableId");
 static ROUTETABLEASSOCIATION_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteTableAssociation$SubnetId",
         "com.amazonaws.ec2",
         "RouteTableAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "subnet_id",
     "SubnetId",
 ,
-96
+)
 .with_xml_name("subnetId");
 static ROUTETABLEASSOCIATION_MEMBER_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteTableAssociation$GatewayId",
         "com.amazonaws.ec2",
         "RouteTableAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "gateway_id",
     "GatewayId",
 ,
-107
+)
 .with_xml_name("gatewayId");
 static ROUTETABLEASSOCIATION_MEMBER_PUBLIC_IPV4_POOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteTableAssociation$PublicIpv4Pool",
         "com.amazonaws.ec2",
         "RouteTableAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "public_ipv4_pool",
     "PublicIpv4Pool",
 ,
-118
+)
 .with_xml_name("publicIpv4Pool");
 static ROUTETABLEASSOCIATION_MEMBER_ASSOCIATION_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteTableAssociation$AssociationState",
         "com.amazonaws.ec2",
         "RouteTableAssociation",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "association_state",
     "AssociationState",
 ,
-129
+)
 .with_xml_name("associationState");
 static ROUTETABLEASSOCIATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ROUTETABLEASSOCIATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &ROUTETABLEASSOCIATION_MEMBER_MAIN,
         &ROUTETABLEASSOCIATION_MEMBER_ROUTE_TABLE_ASSOCIATION_ID,
         &ROUTETABLEASSOCIATION_MEMBER_ROUTE_TABLE_ID,
         &ROUTETABLEASSOCIATION_MEMBER_SUBNET_ID,
         &ROUTETABLEASSOCIATION_MEMBER_GATEWAY_ID,
         &ROUTETABLEASSOCIATION_MEMBER_PUBLIC_IPV4_POOL,
         &ROUTETABLEASSOCIATION_MEMBER_ASSOCIATION_STATE,
     ],
 );
 impl RouteTableAssociation {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ROUTETABLEASSOCIATION_SCHEMA;
-147
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RouteTableAssociation {
     #[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.main {
             ser.write_boolean(&ROUTETABLEASSOCIATION_MEMBER_MAIN, *val)?;
-156
+        }
         if let Some(ref val) = self.route_table_association_id {
             ser.write_string(&ROUTETABLEASSOCIATION_MEMBER_ROUTE_TABLE_ASSOCIATION_ID, val)?;
-159
+        }
         if let Some(ref val) = self.route_table_id {
             ser.write_string(&ROUTETABLEASSOCIATION_MEMBER_ROUTE_TABLE_ID, val)?;
-162
+        }
         if let Some(ref val) = self.subnet_id {
             ser.write_string(&ROUTETABLEASSOCIATION_MEMBER_SUBNET_ID, val)?;
-165
+        }
         if let Some(ref val) = self.gateway_id {
             ser.write_string(&ROUTETABLEASSOCIATION_MEMBER_GATEWAY_ID, val)?;
-168
+        }
         if let Some(ref val) = self.public_ipv4_pool {
             ser.write_string(&ROUTETABLEASSOCIATION_MEMBER_PUBLIC_IPV4_POOL, val)?;
-171
+        }
         if let Some(ref val) = self.association_state {
             ser.write_struct(&ROUTETABLEASSOCIATION_MEMBER_ASSOCIATION_STATE, val)?;
-174
+        }
         Ok(())
-176
+    }
-177
+}
 impl RouteTableAssociation {
     /// 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(&ROUTETABLEASSOCIATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ROUTETABLEASSOCIATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.main = Some(deser.read_boolean(member)?);
-196
+                }
                 Some(1) => {
                     builder.route_table_association_id = Some(deser.read_string(member)?);
-199
+                }
                 Some(2) => {
                     builder.route_table_id = Some(deser.read_string(member)?);
-202
+                }
                 Some(3) => {
                     builder.subnet_id = Some(deser.read_string(member)?);
-205
+                }
                 Some(4) => {
                     builder.gateway_id = Some(deser.read_string(member)?);
-208
+                }
                 Some(5) => {
                     builder.public_ipv4_pool = Some(deser.read_string(member)?);
-211
+                }
                 Some(6) => {
                     builder.association_state = Some(crate::types::RouteTableAssociationState::deserialize(deser)?);
-214
+                }
                 _ => {}
-216
+            }
             Ok(())
         })?;
         Ok(builder.build())
-220
+    }
-221
+}
 impl RouteTableAssociation {
     /// 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 RouteTableAssociation {
     /// Creates a new builder-style object to manufacture [`RouteTableAssociation`](crate::types::RouteTableAssociation).
     pub fn builder() -> crate::types::builders::RouteTableAssociationBuilder {
         crate::types::builders::RouteTableAssociationBuilder::default()
-237
+    }
-238
+}
-239
 /// A builder for [`RouteTableAssociation`](crate::types::RouteTableAssociation).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RouteTableAssociationBuilder {
     pub(crate) main: ::std::option::Option<bool>,
     pub(crate) route_table_association_id: ::std::option::Option<::std::string::String>,
     pub(crate) route_table_id: ::std::option::Option<::std::string::String>,
     pub(crate) subnet_id: ::std::option::Option<::std::string::String>,
     pub(crate) gateway_id: ::std::option::Option<::std::string::String>,
     pub(crate) public_ipv4_pool: ::std::option::Option<::std::string::String>,
     pub(crate) association_state: ::std::option::Option<crate::types::RouteTableAssociationState>,
-251
+}
 impl RouteTableAssociationBuilder {
     /// <p>Indicates whether this is the main route table.</p>
     pub fn main(mut self, input: bool) -> Self {
         self.main = ::std::option::Option::Some(input);
         self
-257
+    }
     /// <p>Indicates whether this is the main route table.</p>
     pub fn set_main(mut self, input: ::std::option::Option<bool>) -> Self {
         self.main = input;
         self
-262
+    }

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

@@ -4,4 +134,145 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct RouteTableAssociationState {
     /// <p>The state of the association.</p>
     pub state: ::std::option::Option<crate::types::RouteTableAssociationStateCode>,
     /// <p>The status message, if applicable.</p>
     pub status_message: ::std::option::Option<::std::string::String>,
-11
+}
 impl RouteTableAssociationState {
     /// <p>The state of the association.</p>
     pub fn state(&self) -> ::std::option::Option<&crate::types::RouteTableAssociationStateCode> {
         self.state.as_ref()
-16
+    }
     /// <p>The status message, if applicable.</p>
     pub fn status_message(&self) -> ::std::option::Option<&str> {
         self.status_message.as_deref()
-20
+    }
-21
+}
 static ROUTETABLEASSOCIATIONSTATE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#RouteTableAssociationState",

     "com.amazonaws.ec2",
     "RouteTableAssociationState",
 );
 static ROUTETABLEASSOCIATIONSTATE_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteTableAssociationState$State",
         "com.amazonaws.ec2",
         "RouteTableAssociationState",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "state",
     "State",
 ,
-36
+)
 .with_xml_name("state");
 static ROUTETABLEASSOCIATIONSTATE_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RouteTableAssociationState$StatusMessage",
         "com.amazonaws.ec2",
         "RouteTableAssociationState",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "status_message",
     "StatusMessage",
 ,
-47
+)
 .with_xml_name("statusMessage");
 static ROUTETABLEASSOCIATIONSTATE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ROUTETABLEASSOCIATIONSTATE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &ROUTETABLEASSOCIATIONSTATE_MEMBER_STATE,
         &ROUTETABLEASSOCIATIONSTATE_MEMBER_STATUS_MESSAGE,
     ],
 );
 impl RouteTableAssociationState {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ROUTETABLEASSOCIATIONSTATE_SCHEMA;
-60
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RouteTableAssociationState {
     #[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.state {
             ser.write_string(&ROUTETABLEASSOCIATIONSTATE_MEMBER_STATE, val.as_str())?;
-69
+        }
         if let Some(ref val) = self.status_message {
             ser.write_string(&ROUTETABLEASSOCIATIONSTATE_MEMBER_STATUS_MESSAGE, val)?;
-72
+        }
         Ok(())
-74
+    }
-75
+}
 impl RouteTableAssociationState {
     /// 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(&ROUTETABLEASSOCIATIONSTATE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ROUTETABLEASSOCIATIONSTATE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.state = Some(crate::types::RouteTableAssociationStateCode::from(deser.read_string(member)?.as_str()));
-94
+                }
                 Some(1) => {
                     builder.status_message = Some(deser.read_string(member)?);
-97
+                }
                 _ => {}
-99
+            }
             Ok(())
         })?;
         Ok(builder.build())
-103
+    }
-104
+}
 impl RouteTableAssociationState {
     /// 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 RouteTableAssociationState {
     /// Creates a new builder-style object to manufacture [`RouteTableAssociationState`](crate::types::RouteTableAssociationState).
     pub fn builder() -> crate::types::builders::RouteTableAssociationStateBuilder {
         crate::types::builders::RouteTableAssociationStateBuilder::default()
-120
+    }
-121
+}
-122
 /// A builder for [`RouteTableAssociationState`](crate::types::RouteTableAssociationState).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RouteTableAssociationStateBuilder {
     pub(crate) state: ::std::option::Option<crate::types::RouteTableAssociationStateCode>,
     pub(crate) status_message: ::std::option::Option<::std::string::String>,
-129
+}
 impl RouteTableAssociationStateBuilder {
     /// <p>The state of the association.</p>
     pub fn state(mut self, input: crate::types::RouteTableAssociationStateCode) -> Self {
         self.state = ::std::option::Option::Some(input);
         self
-135
+    }
     /// <p>The state of the association.</p>
     pub fn set_state(mut self, input: ::std::option::Option<crate::types::RouteTableAssociationStateCode>) -> Self {
         self.state = input;
         self
-140
+    }
     /// <p>The state of the association.</p>
     pub fn get_state(&self) -> &::std::option::Option<crate::types::RouteTableAssociationStateCode> {
         &self.state
-144
+    }
     /// <p>The status message, if applicable.</p>

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

@@ -6,6 +154,162 @@

↥ Expand context

 pub struct RuleGroupRuleOptionsPair {
     /// <p>The ARN of the rule group.</p>
     pub rule_group_arn: ::std::option::Option<::std::string::String>,
     /// <p>The rule options.</p>
     pub rule_options: ::std::option::Option<::std::vec::Vec<crate::types::RuleOption>>,
-11
+}
 impl RuleGroupRuleOptionsPair {
     /// <p>The ARN of the rule group.</p>
     pub fn rule_group_arn(&self) -> ::std::option::Option<&str> {
         self.rule_group_arn.as_deref()
-16
+    }
     /// <p>The rule options.</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 `.rule_options.is_none()`.
     pub fn rule_options(&self) -> &[crate::types::RuleOption] {
         self.rule_options.as_deref().unwrap_or_default()
-22
+    }
-23
+}
 static RULEGROUPRULEOPTIONSPAIR_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#RuleGroupRuleOptionsPair",

     "com.amazonaws.ec2",
     "RuleGroupRuleOptionsPair",
 );
 static RULEGROUPRULEOPTIONSPAIR_MEMBER_RULE_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RuleGroupRuleOptionsPair$RuleGroupArn",
         "com.amazonaws.ec2",
         "RuleGroupRuleOptionsPair",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "rule_group_arn",
     "RuleGroupArn",
 ,
-38
+)
 .with_xml_name("ruleGroupArn");
 static RULEGROUPRULEOPTIONSPAIR_MEMBER_RULE_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RuleGroupRuleOptionsPair$RuleOptions",
         "com.amazonaws.ec2",
         "RuleGroupRuleOptionsPair",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "rule_options",
     "RuleOptions",
 ,
-49
+)
 .with_xml_name("ruleOptionSet");
 static RULEGROUPRULEOPTIONSPAIR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RULEGROUPRULEOPTIONSPAIR_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &RULEGROUPRULEOPTIONSPAIR_MEMBER_RULE_GROUP_ARN,
         &RULEGROUPRULEOPTIONSPAIR_MEMBER_RULE_OPTIONS,
     ],
 );
 impl RuleGroupRuleOptionsPair {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RULEGROUPRULEOPTIONSPAIR_SCHEMA;
-62
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RuleGroupRuleOptionsPair {
     #[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.rule_group_arn {
             ser.write_string(&RULEGROUPRULEOPTIONSPAIR_MEMBER_RULE_GROUP_ARN, val)?;
-71
+        }
         if let Some(ref val) = self.rule_options {
             ser.write_list(
                 &RULEGROUPRULEOPTIONSPAIR_MEMBER_RULE_OPTIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::RuleOption::SCHEMA, item)?;
-78
+                    }
                     Ok(())
                 },
             )?;
-82
+        }
         Ok(())
-84
+    }
-85
+}
 impl RuleGroupRuleOptionsPair {
     /// 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(&RULEGROUPRULEOPTIONSPAIR_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RULEGROUPRULEOPTIONSPAIR_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.rule_group_arn = Some(deser.read_string(member)?);
-104
+                }
                 Some(1) => {
                     builder.rule_options = 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::RuleOption::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::RuleOption::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-114
+                }
                 _ => {}
-116
+            }
             Ok(())
         })?;
         Ok(builder.build())
-120
+    }
-121
+}
 impl RuleGroupRuleOptionsPair {
     /// 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 RuleGroupRuleOptionsPair {
     /// Creates a new builder-style object to manufacture [`RuleGroupRuleOptionsPair`](crate::types::RuleGroupRuleOptionsPair).
     pub fn builder() -> crate::types::builders::RuleGroupRuleOptionsPairBuilder {
         crate::types::builders::RuleGroupRuleOptionsPairBuilder::default()
-137
+    }
-138
+}
-139
 /// A builder for [`RuleGroupRuleOptionsPair`](crate::types::RuleGroupRuleOptionsPair).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RuleGroupRuleOptionsPairBuilder {
     pub(crate) rule_group_arn: ::std::option::Option<::std::string::String>,
     pub(crate) rule_options: ::std::option::Option<::std::vec::Vec<crate::types::RuleOption>>,
-146
+}
 impl RuleGroupRuleOptionsPairBuilder {
     /// <p>The ARN of the rule group.</p>
     pub fn rule_group_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.rule_group_arn = ::std::option::Option::Some(input.into());
         self
-152
+    }
     /// <p>The ARN of the rule group.</p>
     pub fn set_rule_group_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.rule_group_arn = input;
         self
-157
+    }
     /// <p>The ARN of the rule group.</p>
     pub fn get_rule_group_arn(&self) -> &::std::option::Option<::std::string::String> {
         &self.rule_group_arn
-161
+    }
     /// Appends an item to `rule_options`.

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

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Describes the type of a stateful rule group.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct RuleGroupTypePair {
     /// <p>The ARN of the rule group.</p>
     pub rule_group_arn: ::std::option::Option<::std::string::String>,
     /// <p>The rule group type. The possible values are <code>Domain List</code> and <code>Suricata</code>.</p>
     pub rule_group_type: ::std::option::Option<::std::string::String>,
-11
+}
 impl RuleGroupTypePair {
     /// <p>The ARN of the rule group.</p>
     pub fn rule_group_arn(&self) -> ::std::option::Option<&str> {
         self.rule_group_arn.as_deref()
-16
+    }
     /// <p>The rule group type. The possible values are <code>Domain List</code> and <code>Suricata</code>.</p>
     pub fn rule_group_type(&self) -> ::std::option::Option<&str> {
         self.rule_group_type.as_deref()
-20
+    }

-21
+}
 static RULEGROUPTYPEPAIR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RuleGroupTypePair", "com.amazonaws.ec2", "RuleGroupTypePair");
 static RULEGROUPTYPEPAIR_MEMBER_RULE_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RuleGroupTypePair$RuleGroupArn",
         "com.amazonaws.ec2",
         "RuleGroupTypePair",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "rule_group_arn",
     "RuleGroupArn",
 ,
-33
+)
 .with_xml_name("ruleGroupArn");
 static RULEGROUPTYPEPAIR_MEMBER_RULE_GROUP_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#RuleGroupTypePair$RuleGroupType",
         "com.amazonaws.ec2",
         "RuleGroupTypePair",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "rule_group_type",
     "RuleGroupType",
 ,
-44
+)
 .with_xml_name("ruleGroupType");
 static RULEGROUPTYPEPAIR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RULEGROUPTYPEPAIR_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&RULEGROUPTYPEPAIR_MEMBER_RULE_GROUP_ARN, &RULEGROUPTYPEPAIR_MEMBER_RULE_GROUP_TYPE],
 );
 impl RuleGroupTypePair {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RULEGROUPTYPEPAIR_SCHEMA;
-54
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RuleGroupTypePair {
     #[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.rule_group_arn {
             ser.write_string(&RULEGROUPTYPEPAIR_MEMBER_RULE_GROUP_ARN, val)?;
-63
+        }
         if let Some(ref val) = self.rule_group_type {
             ser.write_string(&RULEGROUPTYPEPAIR_MEMBER_RULE_GROUP_TYPE, val)?;
-66
+        }
         Ok(())
-68
+    }
-69
+}
 impl RuleGroupTypePair {
     /// 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(&RULEGROUPTYPEPAIR_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RULEGROUPTYPEPAIR_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.rule_group_arn = Some(deser.read_string(member)?);
-88
+                }
                 Some(1) => {
                     builder.rule_group_type = Some(deser.read_string(member)?);
-91
+                }
                 _ => {}
-93
+            }
             Ok(())
         })?;
         Ok(builder.build())
-97
+    }
-98
+}
 impl RuleGroupTypePair {
     /// 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 RuleGroupTypePair {
     /// Creates a new builder-style object to manufacture [`RuleGroupTypePair`](crate::types::RuleGroupTypePair).
     pub fn builder() -> crate::types::builders::RuleGroupTypePairBuilder {
         crate::types::builders::RuleGroupTypePairBuilder::default()
-114
+    }
-115
+}
-116
 /// A builder for [`RuleGroupTypePair`](crate::types::RuleGroupTypePair).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RuleGroupTypePairBuilder {
     pub(crate) rule_group_arn: ::std::option::Option<::std::string::String>,
     pub(crate) rule_group_type: ::std::option::Option<::std::string::String>,
-123
+}
 impl RuleGroupTypePairBuilder {
     /// <p>The ARN of the rule group.</p>
     pub fn rule_group_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.rule_group_arn = ::std::option::Option::Some(input.into());
         self
-129
+    }
     /// <p>The ARN of the rule group.</p>
     pub fn set_rule_group_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.rule_group_arn = input;
         self
-134
+    }
     /// <p>The ARN of the rule group.</p>
     pub fn get_rule_group_arn(&self) -> &::std::option::Option<::std::string::String> {
         &self.rule_group_arn
-138
+    }
     /// <p>The rule group type. The possible values are <code>Domain List</code> and <code>Suricata</code>.</p>

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

@@ -1,1 +140,141 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Describes additional settings for a stateful rule.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct RuleOption {
     /// <p>The Suricata keyword.</p>
     pub keyword: ::std::option::Option<::std::string::String>,
     /// <p>The settings for the keyword.</p>
     pub settings: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-11
+}
 impl RuleOption {
     /// <p>The Suricata keyword.</p>
     pub fn keyword(&self) -> ::std::option::Option<&str> {
         self.keyword.as_deref()
-16
+    }
     /// <p>The settings for the keyword.</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 `.settings.is_none()`.
     pub fn settings(&self) -> &[::std::string::String] {
         self.settings.as_deref().unwrap_or_default()
-22
+    }
-23
+}
 static RULEOPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RuleOption", "com.amazonaws.ec2", "RuleOption");
 static RULEOPTION_MEMBER_KEYWORD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RuleOption$Keyword", "com.amazonaws.ec2", "RuleOption"),
     ::aws_smithy_schema::ShapeType::String,
     "keyword",
     "Keyword",
 ,
-31
+)
 .with_xml_name("keyword");
 static RULEOPTION_MEMBER_SETTINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RuleOption$Settings", "com.amazonaws.ec2", "RuleOption"),
     ::aws_smithy_schema::ShapeType::List,
     "settings",
     "Settings",
 ,
-38
+)
 .with_xml_name("settingSet");
 static RULEOPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RULEOPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&RULEOPTION_MEMBER_KEYWORD, &RULEOPTION_MEMBER_SETTINGS],
 );
 impl RuleOption {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RULEOPTION_SCHEMA;
-48
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RuleOption {
     #[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.keyword {
             ser.write_string(&RULEOPTION_MEMBER_KEYWORD, val)?;
-57
+        }
         if let Some(ref val) = self.settings {
             ser.write_list(
                 &RULEOPTION_MEMBER_SETTINGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-64
+                    }
                     Ok(())
                 },
             )?;
-68
+        }
         Ok(())
-70
+    }
-71
+}
 impl RuleOption {
     /// 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(&RULEOPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RULEOPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.keyword = Some(deser.read_string(member)?);
-90
+                }
                 Some(1) => {
                     builder.settings = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.settings = Some(deser.read_string_list(member)?);
-93
+                }
                 _ => {}
-95
+            }
             Ok(())
         })?;
         Ok(builder.build())
-99
+    }
-100
+}
 impl RuleOption {
     /// 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 RuleOption {
     /// Creates a new builder-style object to manufacture [`RuleOption`](crate::types::RuleOption).
     pub fn builder() -> crate::types::builders::RuleOptionBuilder {
         crate::types::builders::RuleOptionBuilder::default()
-116
+    }
-117
+}
-118
 /// A builder for [`RuleOption`](crate::types::RuleOption).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RuleOptionBuilder {
     pub(crate) keyword: ::std::option::Option<::std::string::String>,
     pub(crate) settings: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-125
+}
 impl RuleOptionBuilder {
     /// <p>The Suricata keyword.</p>
     pub fn keyword(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.keyword = ::std::option::Option::Some(input.into());
         self
-131
+    }
     /// <p>The Suricata keyword.</p>
     pub fn set_keyword(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.keyword = input;
         self
-136
+    }
     /// <p>The Suricata keyword.</p>
     pub fn get_keyword(&self) -> &::std::option::Option<::std::string::String> {
         &self.keyword
-140
+    }
     /// Appends an item to `settings`.

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

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Describes the monitoring of an instance.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct RunInstancesMonitoringEnabled {
     /// <p>Indicates whether detailed monitoring is enabled. Otherwise, basic monitoring is enabled.</p>
     pub enabled: ::std::option::Option<bool>,
-9
+}
 impl RunInstancesMonitoringEnabled {
     /// <p>Indicates whether detailed monitoring is enabled. Otherwise, basic monitoring is enabled.</p>
     pub fn enabled(&self) -> ::std::option::Option<bool> {
         self.enabled
-14
+    }
-15
+}
 static RUNINSTANCESMONITORINGENABLED_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#RunInstancesMonitoringEnabled",

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

↧ Expand context

 pub struct RunInstancesMonitoringEnabledBuilder {
     pub(crate) enabled: ::std::option::Option<bool>,
-102
+}
 impl RunInstancesMonitoringEnabledBuilder {
     /// <p>Indicates whether detailed monitoring is enabled. Otherwise, basic monitoring is enabled.</p>
     /// This field is required.
     pub fn enabled(mut self, input: bool) -> Self {
         self.enabled = ::std::option::Option::Some(input);
         self
-109
+    }
     /// <p>Indicates whether detailed monitoring is enabled. Otherwise, basic monitoring is enabled.</p>
     pub fn set_enabled(mut self, input: ::std::option::Option<bool>) -> Self {
         self.enabled = input;
         self
-114
+    }
     /// <p>Indicates whether detailed monitoring is enabled. Otherwise, basic monitoring is enabled.</p>
     pub fn get_enabled(&self) -> &::std::option::Option<bool> {
         &self.enabled
-118
+    }
     /// Consumes the builder and constructs a [`RunInstancesMonitoringEnabled`](crate::types::RunInstancesMonitoringEnabled).

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

@@ -1,1 +122,133 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The tags to apply to the AMI object that will be stored in the Amazon S3 bucket. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-tagging.html">Categorizing your storage using tags</a> in the <i>Amazon Simple Storage Service User Guide</i>.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct S3ObjectTag {
     /// <p>The key of the tag.</p>
     /// <p>Constraints: Tag keys are case-sensitive and can be up to 128 Unicode characters in length. May not begin with <code>aws</code>:.</p>
     pub key: ::std::option::Option<::std::string::String>,
     /// <p>The value of the tag.</p>
     /// <p>Constraints: Tag values are case-sensitive and can be up to 256 Unicode characters in length.</p>
     pub value: ::std::option::Option<::std::string::String>,
-13
+}
 impl S3ObjectTag {
     /// <p>The key of the tag.</p>
     /// <p>Constraints: Tag keys are case-sensitive and can be up to 128 Unicode characters in length. May not begin with <code>aws</code>:.</p>
     pub fn key(&self) -> ::std::option::Option<&str> {
         self.key.as_deref()
-19
+    }
     /// <p>The value of the tag.</p>

     /// <p>Constraints: Tag values are case-sensitive and can be up to 256 Unicode characters in length.</p>
     pub fn value(&self) -> ::std::option::Option<&str> {
         self.value.as_deref()
-24
+    }
-25
+}
 static S3OBJECTTAG_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#S3ObjectTag", "com.amazonaws.ec2", "S3ObjectTag");
 static S3OBJECTTAG_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#S3ObjectTag$Key", "com.amazonaws.ec2", "S3ObjectTag"),
     ::aws_smithy_schema::ShapeType::String,
     "key",
     "Key",
 ,
 );
 static S3OBJECTTAG_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#S3ObjectTag$Value", "com.amazonaws.ec2", "S3ObjectTag"),
     ::aws_smithy_schema::ShapeType::String,
     "value",
     "Value",
 ,
 );
 static S3OBJECTTAG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     S3OBJECTTAG_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&S3OBJECTTAG_MEMBER_KEY, &S3OBJECTTAG_MEMBER_VALUE],
 );
 impl S3ObjectTag {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &S3OBJECTTAG_SCHEMA;
-48
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for S3ObjectTag {
     #[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.key {
             ser.write_string(&S3OBJECTTAG_MEMBER_KEY, val)?;
-57
+        }
         if let Some(ref val) = self.value {
             ser.write_string(&S3OBJECTTAG_MEMBER_VALUE, val)?;
-60
+        }
         Ok(())
-62
+    }
-63
+}
 impl S3ObjectTag {
     /// 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(&S3OBJECTTAG_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&S3OBJECTTAG_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.key = Some(deser.read_string(member)?);
-82
+                }
                 Some(1) => {
                     builder.value = Some(deser.read_string(member)?);
-85
+                }
                 _ => {}
-87
+            }
             Ok(())
         })?;
         Ok(builder.build())
-91
+    }
-92
+}
 impl S3ObjectTag {
     /// 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 S3ObjectTag {
     /// Creates a new builder-style object to manufacture [`S3ObjectTag`](crate::types::S3ObjectTag).
     pub fn builder() -> crate::types::builders::S3ObjectTagBuilder {
         crate::types::builders::S3ObjectTagBuilder::default()
-108
+    }
-109
+}
-110
 /// A builder for [`S3ObjectTag`](crate::types::S3ObjectTag).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct S3ObjectTagBuilder {
     pub(crate) key: ::std::option::Option<::std::string::String>,
     pub(crate) value: ::std::option::Option<::std::string::String>,
-117
+}
 impl S3ObjectTagBuilder {
     /// <p>The key of the tag.</p>
     /// <p>Constraints: Tag keys are case-sensitive and can be up to 128 Unicode characters in length. May not begin with <code>aws</code>:.</p>
     pub fn key(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.key = ::std::option::Option::Some(input.into());
         self
-124
+    }
     /// <p>The key of the tag.</p>
     /// <p>Constraints: Tag keys are case-sensitive and can be up to 128 Unicode characters in length. May not begin with <code>aws</code>:.</p>
     pub fn set_key(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.key = input;
         self
-130
+    }
     /// <p>The key of the tag.</p>
     /// <p>Constraints: Tag keys are case-sensitive and can be up to 128 Unicode characters in length. May not begin with <code>aws</code>:.</p>
     pub fn get_key(&self) -> &::std::option::Option<::std::string::String> {

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

@@ -26,26 +193,204 @@

↥ Expand context

-26
+    }
     /// <p>The beginning of the file name of the AMI.</p>
     pub fn prefix(&self) -> ::std::option::Option<&str> {
         self.prefix.as_deref()
-30
+    }
     /// <p>An Amazon S3 upload policy that gives Amazon EC2 permission to upload items into Amazon S3 on your behalf.</p>
     pub fn upload_policy(&self) -> ::std::option::Option<&::aws_smithy_types::Blob> {
         self.upload_policy.as_ref()
-34
+    }
     /// <p>The signature of the JSON document.</p>
     pub fn upload_policy_signature(&self) -> ::std::option::Option<&str> {
         self.upload_policy_signature.as_deref()
-38
+    }
-39
+}
 impl ::std::fmt::Debug for S3Storage {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("S3Storage");
         formatter.field("aws_access_key_id", &self.aws_access_key_id);
         formatter.field("bucket", &self.bucket);
         formatter.field("prefix", &self.prefix);

         formatter.field("upload_policy", &self.upload_policy);
         formatter.field("upload_policy_signature", &"*** Sensitive Data Redacted ***");
         formatter.finish()
-49
+    }
-50
+}
 static S3STORAGE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#S3Storage", "com.amazonaws.ec2", "S3Storage");
 static S3STORAGE_MEMBER_AWS_ACCESS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#S3Storage$AWSAccessKeyId", "com.amazonaws.ec2", "S3Storage"),
     ::aws_smithy_schema::ShapeType::String,
     "aws_access_key_id",
     "AWSAccessKeyId",
 ,
 );
 static S3STORAGE_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#S3Storage$Bucket", "com.amazonaws.ec2", "S3Storage"),
     ::aws_smithy_schema::ShapeType::String,
     "bucket",
     "Bucket",
 ,
-64
+)
 .with_xml_name("bucket");
 static S3STORAGE_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#S3Storage$Prefix", "com.amazonaws.ec2", "S3Storage"),
     ::aws_smithy_schema::ShapeType::String,
     "prefix",
     "Prefix",
 ,
-71
+)
 .with_xml_name("prefix");
 static S3STORAGE_MEMBER_UPLOAD_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#S3Storage$UploadPolicy", "com.amazonaws.ec2", "S3Storage"),
     ::aws_smithy_schema::ShapeType::Blob,
     "upload_policy",
     "UploadPolicy",
 ,
-78
+)
 .with_xml_name("uploadPolicy");
 static S3STORAGE_MEMBER_UPLOAD_POLICY_SIGNATURE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#S3Storage$UploadPolicySignature", "com.amazonaws.ec2", "S3Storage"),
     ::aws_smithy_schema::ShapeType::String,
     "upload_policy_signature",
     "UploadPolicySignature",
 ,
-85
+)
 .with_xml_name("uploadPolicySignature");
 static S3STORAGE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     S3STORAGE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &S3STORAGE_MEMBER_AWS_ACCESS_KEY_ID,
         &S3STORAGE_MEMBER_BUCKET,
         &S3STORAGE_MEMBER_PREFIX,
         &S3STORAGE_MEMBER_UPLOAD_POLICY,
         &S3STORAGE_MEMBER_UPLOAD_POLICY_SIGNATURE,
     ],
 );
 impl S3Storage {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &S3STORAGE_SCHEMA;
-101
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for S3Storage {
     #[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.aws_access_key_id {
             ser.write_string(&S3STORAGE_MEMBER_AWS_ACCESS_KEY_ID, val)?;
-110
+        }
         if let Some(ref val) = self.bucket {
             ser.write_string(&S3STORAGE_MEMBER_BUCKET, val)?;
-113
+        }
         if let Some(ref val) = self.prefix {
             ser.write_string(&S3STORAGE_MEMBER_PREFIX, val)?;
-116
+        }
         if let Some(ref val) = self.upload_policy {
             ser.write_blob(&S3STORAGE_MEMBER_UPLOAD_POLICY, val)?;
-119
+        }
         if let Some(ref val) = self.upload_policy_signature {
             ser.write_string(&S3STORAGE_MEMBER_UPLOAD_POLICY_SIGNATURE, val)?;
-122
+        }
         Ok(())
-124
+    }
-125
+}
 impl S3Storage {
     /// 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(&S3STORAGE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&S3STORAGE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.aws_access_key_id = Some(deser.read_string(member)?);
-144
+                }
                 Some(1) => {
                     builder.bucket = Some(deser.read_string(member)?);
-147
+                }
                 Some(2) => {
                     builder.prefix = Some(deser.read_string(member)?);
-150
+                }
                 Some(3) => {
                     builder.upload_policy = Some(deser.read_blob(member)?);
-153
+                }
                 Some(4) => {
                     builder.upload_policy_signature = Some(deser.read_string(member)?);
-156
+                }
                 _ => {}
-158
+            }
             Ok(())
         })?;
         Ok(builder.build())
-162
+    }
-163
+}
 impl S3Storage {
     /// 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 S3Storage {
     /// Creates a new builder-style object to manufacture [`S3Storage`](crate::types::S3Storage).
     pub fn builder() -> crate::types::builders::S3StorageBuilder {
         crate::types::builders::S3StorageBuilder::default()
-179
+    }
-180
+}
-181
 /// A builder for [`S3Storage`](crate::types::S3Storage).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct S3StorageBuilder {
     pub(crate) aws_access_key_id: ::std::option::Option<::std::string::String>,
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     pub(crate) prefix: ::std::option::Option<::std::string::String>,
     pub(crate) upload_policy: ::std::option::Option<::aws_smithy_types::Blob>,
     pub(crate) upload_policy_signature: ::std::option::Option<::std::string::String>,
-191
+}
 impl S3StorageBuilder {
     /// <p>The access key ID of the owner of the bucket. Before you specify a value for your access key ID, review and follow the guidance in <a href="https://docs.aws.amazon.com/accounts/latest/reference/best-practices.html">Best Practices for Amazon Web Services accounts</a> in the <i>Account ManagementReference Guide</i>.</p>
     pub fn aws_access_key_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.aws_access_key_id = ::std::option::Option::Some(input.into());
         self
-197
+    }
     /// <p>The access key ID of the owner of the bucket. Before you specify a value for your access key ID, review and follow the guidance in <a href="https://docs.aws.amazon.com/accounts/latest/reference/best-practices.html">Best Practices for Amazon Web Services accounts</a> in the <i>Account ManagementReference Guide</i>.</p>
     pub fn set_aws_access_key_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.aws_access_key_id = input;
         self
-202
+    }
     /// <p>The access key ID of the owner of the bucket. Before you specify a value for your access key ID, review and follow the guidance in <a href="https://docs.aws.amazon.com/accounts/latest/reference/best-practices.html">Best Practices for Amazon Web Services accounts</a> in the <i>Account ManagementReference Guide</i>.</p>
     pub fn get_aws_access_key_id(&self) -> &::std::option::Option<::std::string::String> {

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

@@ -79,79 +281,281 @@

↥ Expand context

     /// <p>The Scheduled Instance ID.</p>
     pub fn scheduled_instance_id(&self) -> ::std::option::Option<&str> {
         self.scheduled_instance_id.as_deref()
-82
+    }
     /// <p>The number of hours in the schedule.</p>
     pub fn slot_duration_in_hours(&self) -> ::std::option::Option<i32> {
         self.slot_duration_in_hours
-86
+    }
     /// <p>The end date for the Scheduled Instance.</p>
     pub fn term_end_date(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.term_end_date.as_ref()
-90
+    }
     /// <p>The start date for the Scheduled Instance.</p>
     pub fn term_start_date(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.term_start_date.as_ref()
-94
+    }
     /// <p>The total number of hours for a single instance for the entire term.</p>
     pub fn total_scheduled_instance_hours(&self) -> ::std::option::Option<i32> {
         self.total_scheduled_instance_hours
-98
+    }

-99
+}
 static SCHEDULEDINSTANCE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ScheduledInstance", "com.amazonaws.ec2", "ScheduledInstance");
 static SCHEDULEDINSTANCE_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstance$AvailabilityZone",
         "com.amazonaws.ec2",
         "ScheduledInstance",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone",
     "AvailabilityZone",
 ,
-111
+)
 .with_xml_name("availabilityZone");
 static SCHEDULEDINSTANCE_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ScheduledInstance$CreateDate", "com.amazonaws.ec2", "ScheduledInstance"),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "create_date",
     "CreateDate",
 ,
-118
+)
 .with_xml_name("createDate");
 static SCHEDULEDINSTANCE_MEMBER_HOURLY_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstance$HourlyPrice",
         "com.amazonaws.ec2",
         "ScheduledInstance",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "hourly_price",
     "HourlyPrice",
 ,
-129
+)
 .with_xml_name("hourlyPrice");
 static SCHEDULEDINSTANCE_MEMBER_INSTANCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstance$InstanceCount",
         "com.amazonaws.ec2",
         "ScheduledInstance",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "instance_count",
     "InstanceCount",
 ,
-140
+)
 .with_xml_name("instanceCount");
 static SCHEDULEDINSTANCE_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstance$InstanceType",
         "com.amazonaws.ec2",
         "ScheduledInstance",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_type",
     "InstanceType",
 ,
-151
+)
 .with_xml_name("instanceType");
 static SCHEDULEDINSTANCE_MEMBER_NETWORK_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstance$NetworkPlatform",
         "com.amazonaws.ec2",
         "ScheduledInstance",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "network_platform",
     "NetworkPlatform",
 ,
-162
+)
 .with_xml_name("networkPlatform");
 static SCHEDULEDINSTANCE_MEMBER_NEXT_SLOT_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstance$NextSlotStartTime",
         "com.amazonaws.ec2",
         "ScheduledInstance",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "next_slot_start_time",
     "NextSlotStartTime",
 ,
-173
+)
 .with_xml_name("nextSlotStartTime");
 static SCHEDULEDINSTANCE_MEMBER_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ScheduledInstance$Platform", "com.amazonaws.ec2", "ScheduledInstance"),
     ::aws_smithy_schema::ShapeType::String,
     "platform",
     "Platform",
 ,
-180
+)
 .with_xml_name("platform");
 static SCHEDULEDINSTANCE_MEMBER_PREVIOUS_SLOT_END_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstance$PreviousSlotEndTime",
         "com.amazonaws.ec2",
         "ScheduledInstance",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "previous_slot_end_time",
     "PreviousSlotEndTime",
 ,
-191
+)
 .with_xml_name("previousSlotEndTime");
 static SCHEDULEDINSTANCE_MEMBER_RECURRENCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ScheduledInstance$Recurrence", "com.amazonaws.ec2", "ScheduledInstance"),
     ::aws_smithy_schema::ShapeType::Structure,
     "recurrence",
     "Recurrence",
 ,
-198
+)
 .with_xml_name("recurrence");
 static SCHEDULEDINSTANCE_MEMBER_SCHEDULED_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstance$ScheduledInstanceId",
         "com.amazonaws.ec2",
         "ScheduledInstance",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "scheduled_instance_id",
     "ScheduledInstanceId",
 ,
-209
+)
 .with_xml_name("scheduledInstanceId");
 static SCHEDULEDINSTANCE_MEMBER_SLOT_DURATION_IN_HOURS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstance$SlotDurationInHours",
         "com.amazonaws.ec2",
         "ScheduledInstance",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "slot_duration_in_hours",
     "SlotDurationInHours",
 ,
-220
+)
 .with_xml_name("slotDurationInHours");
 static SCHEDULEDINSTANCE_MEMBER_TERM_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstance$TermEndDate",
         "com.amazonaws.ec2",
         "ScheduledInstance",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "term_end_date",
     "TermEndDate",
 ,
-231
+)
 .with_xml_name("termEndDate");
 static SCHEDULEDINSTANCE_MEMBER_TERM_START_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstance$TermStartDate",
         "com.amazonaws.ec2",
         "ScheduledInstance",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "term_start_date",
     "TermStartDate",
 ,
-242
+)
 .with_xml_name("termStartDate");
 static SCHEDULEDINSTANCE_MEMBER_TOTAL_SCHEDULED_INSTANCE_HOURS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstance$TotalScheduledInstanceHours",
         "com.amazonaws.ec2",
         "ScheduledInstance",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "total_scheduled_instance_hours",
     "TotalScheduledInstanceHours",
 ,
-253
+)
 .with_xml_name("totalScheduledInstanceHours");
 static SCHEDULEDINSTANCE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SCHEDULEDINSTANCE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SCHEDULEDINSTANCE_MEMBER_AVAILABILITY_ZONE,
         &SCHEDULEDINSTANCE_MEMBER_CREATE_DATE,
         &SCHEDULEDINSTANCE_MEMBER_HOURLY_PRICE,

↧ Expand context

         &SCHEDULEDINSTANCE_MEMBER_INSTANCE_COUNT,
         &SCHEDULEDINSTANCE_MEMBER_INSTANCE_TYPE,
         &SCHEDULEDINSTANCE_MEMBER_NETWORK_PLATFORM,
         &SCHEDULEDINSTANCE_MEMBER_NEXT_SLOT_START_TIME,
         &SCHEDULEDINSTANCE_MEMBER_PLATFORM,
         &SCHEDULEDINSTANCE_MEMBER_PREVIOUS_SLOT_END_TIME,
         &SCHEDULEDINSTANCE_MEMBER_RECURRENCE,
         &SCHEDULEDINSTANCE_MEMBER_SCHEDULED_INSTANCE_ID,
         &SCHEDULEDINSTANCE_MEMBER_SLOT_DURATION_IN_HOURS,
         &SCHEDULEDINSTANCE_MEMBER_TERM_END_DATE,
         &SCHEDULEDINSTANCE_MEMBER_TERM_START_DATE,
         &SCHEDULEDINSTANCE_MEMBER_TOTAL_SCHEDULED_INSTANCE_HOURS,
     ],
 );
 impl ScheduledInstance {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SCHEDULEDINSTANCE_SCHEMA;
-279
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ScheduledInstance {
     #[allow(unused_variables, clippy::diverging_sub_expression)]

@@ -306,306 +431,442 @@

↥ Expand context

-306
+        }
         if let Some(ref val) = self.platform {
             ser.write_string(&SCHEDULEDINSTANCE_MEMBER_PLATFORM, val)?;
-309
+        }
         if let Some(ref val) = self.previous_slot_end_time {
             ser.write_timestamp(&SCHEDULEDINSTANCE_MEMBER_PREVIOUS_SLOT_END_TIME, val)?;
-312
+        }
         if let Some(ref val) = self.recurrence {
             ser.write_struct(&SCHEDULEDINSTANCE_MEMBER_RECURRENCE, val)?;
-315
+        }
         if let Some(ref val) = self.scheduled_instance_id {
             ser.write_string(&SCHEDULEDINSTANCE_MEMBER_SCHEDULED_INSTANCE_ID, val)?;
-318
+        }
         if let Some(ref val) = self.slot_duration_in_hours {
             ser.write_integer(&SCHEDULEDINSTANCE_MEMBER_SLOT_DURATION_IN_HOURS, *val)?;
-321
+        }
         if let Some(ref val) = self.term_end_date {
             ser.write_timestamp(&SCHEDULEDINSTANCE_MEMBER_TERM_END_DATE, val)?;
-324
+        }
         if let Some(ref val) = self.term_start_date {

             ser.write_timestamp(&SCHEDULEDINSTANCE_MEMBER_TERM_START_DATE, val)?;
-327
+        }
         if let Some(ref val) = self.total_scheduled_instance_hours {
             ser.write_integer(&SCHEDULEDINSTANCE_MEMBER_TOTAL_SCHEDULED_INSTANCE_HOURS, *val)?;
-330
+        }
         Ok(())
-332
+    }
-333
+}
 impl ScheduledInstance {
     /// 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(&SCHEDULEDINSTANCE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SCHEDULEDINSTANCE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.availability_zone = Some(deser.read_string(member)?);
-352
+                }
                 Some(1) => {
                     builder.create_date = Some(deser.read_timestamp(member)?);
-355
+                }
                 Some(2) => {
                     builder.hourly_price = Some(deser.read_string(member)?);
-358
+                }
                 Some(3) => {
                     builder.instance_count = Some(deser.read_integer(member)?);
-361
+                }
                 Some(4) => {
                     builder.instance_type = Some(deser.read_string(member)?);
-364
+                }
                 Some(5) => {
                     builder.network_platform = Some(deser.read_string(member)?);
-367
+                }
                 Some(6) => {
                     builder.next_slot_start_time = Some(deser.read_timestamp(member)?);
-370
+                }
                 Some(7) => {
                     builder.platform = Some(deser.read_string(member)?);
-373
+                }
                 Some(8) => {
                     builder.previous_slot_end_time = Some(deser.read_timestamp(member)?);
-376
+                }
                 Some(9) => {
                     builder.recurrence = Some(crate::types::ScheduledInstanceRecurrence::deserialize(deser)?);
-379
+                }
                 Some(10) => {
                     builder.scheduled_instance_id = Some(deser.read_string(member)?);
-382
+                }
                 Some(11) => {
                     builder.slot_duration_in_hours = Some(deser.read_integer(member)?);
-385
+                }
                 Some(12) => {
                     builder.term_end_date = Some(deser.read_timestamp(member)?);
-388
+                }
                 Some(13) => {
                     builder.term_start_date = Some(deser.read_timestamp(member)?);
-391
+                }
                 Some(14) => {
                     builder.total_scheduled_instance_hours = Some(deser.read_integer(member)?);
-394
+                }
                 _ => {}
-396
+            }
             Ok(())
         })?;
         Ok(builder.build())
-400
+    }
-401
+}
 impl ScheduledInstance {
     /// 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 ScheduledInstance {
     /// Creates a new builder-style object to manufacture [`ScheduledInstance`](crate::types::ScheduledInstance).
     pub fn builder() -> crate::types::builders::ScheduledInstanceBuilder {
         crate::types::builders::ScheduledInstanceBuilder::default()
-417
+    }
-418
+}
-419
 /// A builder for [`ScheduledInstance`](crate::types::ScheduledInstance).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ScheduledInstanceBuilder {
     pub(crate) availability_zone: ::std::option::Option<::std::string::String>,
     pub(crate) create_date: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) hourly_price: ::std::option::Option<::std::string::String>,
     pub(crate) instance_count: ::std::option::Option<i32>,
     pub(crate) instance_type: ::std::option::Option<::std::string::String>,
     pub(crate) network_platform: ::std::option::Option<::std::string::String>,
     pub(crate) next_slot_start_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) platform: ::std::option::Option<::std::string::String>,
     pub(crate) previous_slot_end_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) recurrence: ::std::option::Option<crate::types::ScheduledInstanceRecurrence>,
     pub(crate) scheduled_instance_id: ::std::option::Option<::std::string::String>,
     pub(crate) slot_duration_in_hours: ::std::option::Option<i32>,
     pub(crate) term_end_date: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) term_start_date: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) total_scheduled_instance_hours: ::std::option::Option<i32>,
-439
+}
 impl ScheduledInstanceBuilder {
     /// <p>The Availability Zone.</p>
     pub fn availability_zone(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {

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

@@ -70,70 +262,262 @@

↥ Expand context

-70
+    }
     /// <p>The purchase token. This token expires in two hours.</p>
     pub fn purchase_token(&self) -> ::std::option::Option<&str> {
         self.purchase_token.as_deref()
-74
+    }
     /// <p>The schedule recurrence.</p>
     pub fn recurrence(&self) -> ::std::option::Option<&crate::types::ScheduledInstanceRecurrence> {
         self.recurrence.as_ref()
-78
+    }
     /// <p>The number of hours in the schedule.</p>
     pub fn slot_duration_in_hours(&self) -> ::std::option::Option<i32> {
         self.slot_duration_in_hours
-82
+    }
     /// <p>The total number of hours for a single instance for the entire term.</p>
     pub fn total_scheduled_instance_hours(&self) -> ::std::option::Option<i32> {
         self.total_scheduled_instance_hours
-86
+    }
-87
+}
 static SCHEDULEDINSTANCEAVAILABILITY_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#ScheduledInstanceAvailability",

     "com.amazonaws.ec2",
     "ScheduledInstanceAvailability",
 );
 static SCHEDULEDINSTANCEAVAILABILITY_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceAvailability$AvailabilityZone",
         "com.amazonaws.ec2",
         "ScheduledInstanceAvailability",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone",
     "AvailabilityZone",
 ,
-102
+)
 .with_xml_name("availabilityZone");
 static SCHEDULEDINSTANCEAVAILABILITY_MEMBER_AVAILABLE_INSTANCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceAvailability$AvailableInstanceCount",
         "com.amazonaws.ec2",
         "ScheduledInstanceAvailability",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "available_instance_count",
     "AvailableInstanceCount",
 ,
-113
+)
 .with_xml_name("availableInstanceCount");
 static SCHEDULEDINSTANCEAVAILABILITY_MEMBER_FIRST_SLOT_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceAvailability$FirstSlotStartTime",
         "com.amazonaws.ec2",
         "ScheduledInstanceAvailability",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "first_slot_start_time",
     "FirstSlotStartTime",
 ,
-124
+)
 .with_xml_name("firstSlotStartTime");
 static SCHEDULEDINSTANCEAVAILABILITY_MEMBER_HOURLY_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceAvailability$HourlyPrice",
         "com.amazonaws.ec2",
         "ScheduledInstanceAvailability",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "hourly_price",
     "HourlyPrice",
 ,
-135
+)
 .with_xml_name("hourlyPrice");
 static SCHEDULEDINSTANCEAVAILABILITY_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceAvailability$InstanceType",
         "com.amazonaws.ec2",
         "ScheduledInstanceAvailability",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_type",
     "InstanceType",
 ,
-146
+)
 .with_xml_name("instanceType");
 static SCHEDULEDINSTANCEAVAILABILITY_MEMBER_MAX_TERM_DURATION_IN_DAYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceAvailability$MaxTermDurationInDays",
         "com.amazonaws.ec2",
         "ScheduledInstanceAvailability",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_term_duration_in_days",
     "MaxTermDurationInDays",
 ,
-157
+)
 .with_xml_name("maxTermDurationInDays");
 static SCHEDULEDINSTANCEAVAILABILITY_MEMBER_MIN_TERM_DURATION_IN_DAYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceAvailability$MinTermDurationInDays",
         "com.amazonaws.ec2",
         "ScheduledInstanceAvailability",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "min_term_duration_in_days",
     "MinTermDurationInDays",
 ,
-168
+)
 .with_xml_name("minTermDurationInDays");
 static SCHEDULEDINSTANCEAVAILABILITY_MEMBER_NETWORK_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceAvailability$NetworkPlatform",
         "com.amazonaws.ec2",
         "ScheduledInstanceAvailability",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "network_platform",
     "NetworkPlatform",
 ,
-179
+)
 .with_xml_name("networkPlatform");
 static SCHEDULEDINSTANCEAVAILABILITY_MEMBER_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceAvailability$Platform",
         "com.amazonaws.ec2",
         "ScheduledInstanceAvailability",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "platform",
     "Platform",
 ,
-190
+)
 .with_xml_name("platform");
 static SCHEDULEDINSTANCEAVAILABILITY_MEMBER_PURCHASE_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceAvailability$PurchaseToken",
         "com.amazonaws.ec2",
         "ScheduledInstanceAvailability",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "purchase_token",
     "PurchaseToken",
 ,
-201
+)
 .with_xml_name("purchaseToken");
 static SCHEDULEDINSTANCEAVAILABILITY_MEMBER_RECURRENCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceAvailability$Recurrence",
         "com.amazonaws.ec2",
         "ScheduledInstanceAvailability",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "recurrence",
     "Recurrence",
 ,
-212
+)
 .with_xml_name("recurrence");
 static SCHEDULEDINSTANCEAVAILABILITY_MEMBER_SLOT_DURATION_IN_HOURS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceAvailability$SlotDurationInHours",
         "com.amazonaws.ec2",
         "ScheduledInstanceAvailability",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "slot_duration_in_hours",
     "SlotDurationInHours",
 ,
-223
+)
 .with_xml_name("slotDurationInHours");
 static SCHEDULEDINSTANCEAVAILABILITY_MEMBER_TOTAL_SCHEDULED_INSTANCE_HOURS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceAvailability$TotalScheduledInstanceHours",
         "com.amazonaws.ec2",
         "ScheduledInstanceAvailability",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "total_scheduled_instance_hours",
     "TotalScheduledInstanceHours",
 ,
-234
+)
 .with_xml_name("totalScheduledInstanceHours");
 static SCHEDULEDINSTANCEAVAILABILITY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SCHEDULEDINSTANCEAVAILABILITY_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SCHEDULEDINSTANCEAVAILABILITY_MEMBER_AVAILABILITY_ZONE,
         &SCHEDULEDINSTANCEAVAILABILITY_MEMBER_AVAILABLE_INSTANCE_COUNT,
         &SCHEDULEDINSTANCEAVAILABILITY_MEMBER_FIRST_SLOT_START_TIME,

↧ Expand context

         &SCHEDULEDINSTANCEAVAILABILITY_MEMBER_HOURLY_PRICE,
         &SCHEDULEDINSTANCEAVAILABILITY_MEMBER_INSTANCE_TYPE,
         &SCHEDULEDINSTANCEAVAILABILITY_MEMBER_MAX_TERM_DURATION_IN_DAYS,
         &SCHEDULEDINSTANCEAVAILABILITY_MEMBER_MIN_TERM_DURATION_IN_DAYS,
         &SCHEDULEDINSTANCEAVAILABILITY_MEMBER_NETWORK_PLATFORM,
         &SCHEDULEDINSTANCEAVAILABILITY_MEMBER_PLATFORM,
         &SCHEDULEDINSTANCEAVAILABILITY_MEMBER_PURCHASE_TOKEN,
         &SCHEDULEDINSTANCEAVAILABILITY_MEMBER_RECURRENCE,
         &SCHEDULEDINSTANCEAVAILABILITY_MEMBER_SLOT_DURATION_IN_HOURS,
         &SCHEDULEDINSTANCEAVAILABILITY_MEMBER_TOTAL_SCHEDULED_INSTANCE_HOURS,
     ],
 );
 impl ScheduledInstanceAvailability {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SCHEDULEDINSTANCEAVAILABILITY_SCHEMA;
-258
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ScheduledInstanceAvailability {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,

@@ -279,279 +398,409 @@

↥ Expand context

-279
+        }
         if let Some(ref val) = self.max_term_duration_in_days {
             ser.write_integer(&SCHEDULEDINSTANCEAVAILABILITY_MEMBER_MAX_TERM_DURATION_IN_DAYS, *val)?;
-282
+        }
         if let Some(ref val) = self.min_term_duration_in_days {
             ser.write_integer(&SCHEDULEDINSTANCEAVAILABILITY_MEMBER_MIN_TERM_DURATION_IN_DAYS, *val)?;
-285
+        }
         if let Some(ref val) = self.network_platform {
             ser.write_string(&SCHEDULEDINSTANCEAVAILABILITY_MEMBER_NETWORK_PLATFORM, val)?;
-288
+        }
         if let Some(ref val) = self.platform {
             ser.write_string(&SCHEDULEDINSTANCEAVAILABILITY_MEMBER_PLATFORM, val)?;
-291
+        }
         if let Some(ref val) = self.purchase_token {
             ser.write_string(&SCHEDULEDINSTANCEAVAILABILITY_MEMBER_PURCHASE_TOKEN, val)?;
-294
+        }
         if let Some(ref val) = self.recurrence {
             ser.write_struct(&SCHEDULEDINSTANCEAVAILABILITY_MEMBER_RECURRENCE, val)?;
-297
+        }
         if let Some(ref val) = self.slot_duration_in_hours {

             ser.write_integer(&SCHEDULEDINSTANCEAVAILABILITY_MEMBER_SLOT_DURATION_IN_HOURS, *val)?;
-300
+        }
         if let Some(ref val) = self.total_scheduled_instance_hours {
             ser.write_integer(&SCHEDULEDINSTANCEAVAILABILITY_MEMBER_TOTAL_SCHEDULED_INSTANCE_HOURS, *val)?;
-303
+        }
         Ok(())
-305
+    }
-306
+}
 impl ScheduledInstanceAvailability {
     /// 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(&SCHEDULEDINSTANCEAVAILABILITY_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SCHEDULEDINSTANCEAVAILABILITY_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.availability_zone = Some(deser.read_string(member)?);
-325
+                }
                 Some(1) => {
                     builder.available_instance_count = Some(deser.read_integer(member)?);
-328
+                }
                 Some(2) => {
                     builder.first_slot_start_time = Some(deser.read_timestamp(member)?);
-331
+                }
                 Some(3) => {
                     builder.hourly_price = Some(deser.read_string(member)?);
-334
+                }
                 Some(4) => {
                     builder.instance_type = Some(deser.read_string(member)?);
-337
+                }
                 Some(5) => {
                     builder.max_term_duration_in_days = Some(deser.read_integer(member)?);
-340
+                }
                 Some(6) => {
                     builder.min_term_duration_in_days = Some(deser.read_integer(member)?);
-343
+                }
                 Some(7) => {
                     builder.network_platform = Some(deser.read_string(member)?);
-346
+                }
                 Some(8) => {
                     builder.platform = Some(deser.read_string(member)?);
-349
+                }
                 Some(9) => {
                     builder.purchase_token = Some(deser.read_string(member)?);
-352
+                }
                 Some(10) => {
                     builder.recurrence = Some(crate::types::ScheduledInstanceRecurrence::deserialize(deser)?);
-355
+                }
                 Some(11) => {
                     builder.slot_duration_in_hours = Some(deser.read_integer(member)?);
-358
+                }
                 Some(12) => {
                     builder.total_scheduled_instance_hours = Some(deser.read_integer(member)?);
-361
+                }
                 _ => {}
-363
+            }
             Ok(())
         })?;
         Ok(builder.build())
-367
+    }
-368
+}
 impl ScheduledInstanceAvailability {
     /// 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 ScheduledInstanceAvailability {
     /// Creates a new builder-style object to manufacture [`ScheduledInstanceAvailability`](crate::types::ScheduledInstanceAvailability).
     pub fn builder() -> crate::types::builders::ScheduledInstanceAvailabilityBuilder {
         crate::types::builders::ScheduledInstanceAvailabilityBuilder::default()
-384
+    }
-385
+}
-386
 /// A builder for [`ScheduledInstanceAvailability`](crate::types::ScheduledInstanceAvailability).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ScheduledInstanceAvailabilityBuilder {
     pub(crate) availability_zone: ::std::option::Option<::std::string::String>,
     pub(crate) available_instance_count: ::std::option::Option<i32>,
     pub(crate) first_slot_start_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) hourly_price: ::std::option::Option<::std::string::String>,
     pub(crate) instance_type: ::std::option::Option<::std::string::String>,
     pub(crate) max_term_duration_in_days: ::std::option::Option<i32>,
     pub(crate) min_term_duration_in_days: ::std::option::Option<i32>,
     pub(crate) network_platform: ::std::option::Option<::std::string::String>,
     pub(crate) platform: ::std::option::Option<::std::string::String>,
     pub(crate) purchase_token: ::std::option::Option<::std::string::String>,
     pub(crate) recurrence: ::std::option::Option<crate::types::ScheduledInstanceRecurrence>,
     pub(crate) slot_duration_in_hours: ::std::option::Option<i32>,
     pub(crate) total_scheduled_instance_hours: ::std::option::Option<i32>,
-404
+}
 impl ScheduledInstanceAvailabilityBuilder {
     /// <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

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

@@ -24,24 +226,227 @@

↥ Expand context

     pub fn interval(&self) -> ::std::option::Option<i32> {
         self.interval
-26
+    }
     /// <p>The days. For a monthly schedule, this is one or more days of the month (1-31). For a weekly schedule, this is one or more days of the week (1-7, where 1 is Sunday).</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 `.occurrence_day_set.is_none()`.
     pub fn occurrence_day_set(&self) -> &[i32] {
         self.occurrence_day_set.as_deref().unwrap_or_default()
-32
+    }
     /// <p>Indicates whether the occurrence is relative to the end of the specified week or month.</p>
     pub fn occurrence_relative_to_end(&self) -> ::std::option::Option<bool> {
         self.occurrence_relative_to_end
-36
+    }
     /// <p>The unit for <code>occurrenceDaySet</code> (<code>DayOfWeek</code> or <code>DayOfMonth</code>).</p>
     pub fn occurrence_unit(&self) -> ::std::option::Option<&str> {
         self.occurrence_unit.as_deref()
-40
+    }
-41
+}
 static SCHEDULEDINSTANCERECURRENCE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#ScheduledInstanceRecurrence",

     "com.amazonaws.ec2",
     "ScheduledInstanceRecurrence",
 );
 static SCHEDULEDINSTANCERECURRENCE_MEMBER_FREQUENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceRecurrence$Frequency",
         "com.amazonaws.ec2",
         "ScheduledInstanceRecurrence",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "frequency",
     "Frequency",
 ,
-56
+)
 .with_xml_name("frequency");
 static SCHEDULEDINSTANCERECURRENCE_MEMBER_INTERVAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceRecurrence$Interval",
         "com.amazonaws.ec2",
         "ScheduledInstanceRecurrence",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "interval",
     "Interval",
 ,
-67
+)
 .with_xml_name("interval");
 static SCHEDULEDINSTANCERECURRENCE_MEMBER_OCCURRENCE_DAY_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceRecurrence$OccurrenceDaySet",
         "com.amazonaws.ec2",
         "ScheduledInstanceRecurrence",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "occurrence_day_set",
     "OccurrenceDaySet",
 ,
-78
+)
 .with_xml_name("occurrenceDaySet");
 static SCHEDULEDINSTANCERECURRENCE_MEMBER_OCCURRENCE_RELATIVE_TO_END: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceRecurrence$OccurrenceRelativeToEnd",
         "com.amazonaws.ec2",
         "ScheduledInstanceRecurrence",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "occurrence_relative_to_end",
     "OccurrenceRelativeToEnd",
 ,
-89
+)
 .with_xml_name("occurrenceRelativeToEnd");
 static SCHEDULEDINSTANCERECURRENCE_MEMBER_OCCURRENCE_UNIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceRecurrence$OccurrenceUnit",
         "com.amazonaws.ec2",
         "ScheduledInstanceRecurrence",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "occurrence_unit",
     "OccurrenceUnit",
 ,
-100
+)
 .with_xml_name("occurrenceUnit");
 static SCHEDULEDINSTANCERECURRENCE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SCHEDULEDINSTANCERECURRENCE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SCHEDULEDINSTANCERECURRENCE_MEMBER_FREQUENCY,
         &SCHEDULEDINSTANCERECURRENCE_MEMBER_INTERVAL,
         &SCHEDULEDINSTANCERECURRENCE_MEMBER_OCCURRENCE_DAY_SET,
         &SCHEDULEDINSTANCERECURRENCE_MEMBER_OCCURRENCE_RELATIVE_TO_END,
         &SCHEDULEDINSTANCERECURRENCE_MEMBER_OCCURRENCE_UNIT,
     ],
 );
 impl ScheduledInstanceRecurrence {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SCHEDULEDINSTANCERECURRENCE_SCHEMA;
-116
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ScheduledInstanceRecurrence {
     #[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.frequency {
             ser.write_string(&SCHEDULEDINSTANCERECURRENCE_MEMBER_FREQUENCY, val)?;
-125
+        }
         if let Some(ref val) = self.interval {
             ser.write_integer(&SCHEDULEDINSTANCERECURRENCE_MEMBER_INTERVAL, *val)?;
-128
+        }
         if let Some(ref val) = self.occurrence_day_set {
             ser.write_list(
                 &SCHEDULEDINSTANCERECURRENCE_MEMBER_OCCURRENCE_DAY_SET,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_integer(&aws_smithy_schema::prelude::INTEGER, *item)?;
-135
+                    }
                     Ok(())
                 },
             )?;
-139
+        }
         if let Some(ref val) = self.occurrence_relative_to_end {
             ser.write_boolean(&SCHEDULEDINSTANCERECURRENCE_MEMBER_OCCURRENCE_RELATIVE_TO_END, *val)?;
-142
+        }
         if let Some(ref val) = self.occurrence_unit {
             ser.write_string(&SCHEDULEDINSTANCERECURRENCE_MEMBER_OCCURRENCE_UNIT, val)?;
-145
+        }
         Ok(())
-147
+    }
-148
+}
 impl ScheduledInstanceRecurrence {
     /// 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(&SCHEDULEDINSTANCERECURRENCE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SCHEDULEDINSTANCERECURRENCE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.frequency = Some(deser.read_string(member)?);
-167
+                }
                 Some(1) => {
                     builder.interval = Some(deser.read_integer(member)?);
-170
+                }
                 Some(2) => {
                     builder.occurrence_day_set = 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_integer(member)?);
                             Ok(list)
                         })?
                     });
                     builder.occurrence_day_set = Some(deser.read_integer_list(member)?);
-173
+                }
                 Some(3) => {
                     builder.occurrence_relative_to_end = Some(deser.read_boolean(member)?);
-176
+                }
                 Some(4) => {
                     builder.occurrence_unit = Some(deser.read_string(member)?);
-179
+                }
                 _ => {}
-181
+            }
             Ok(())
         })?;
         Ok(builder.build())
-185
+    }
-186
+}
 impl ScheduledInstanceRecurrence {
     /// 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 ScheduledInstanceRecurrence {
     /// Creates a new builder-style object to manufacture [`ScheduledInstanceRecurrence`](crate::types::ScheduledInstanceRecurrence).
     pub fn builder() -> crate::types::builders::ScheduledInstanceRecurrenceBuilder {
         crate::types::builders::ScheduledInstanceRecurrenceBuilder::default()
-202
+    }
-203
+}
-204
 /// A builder for [`ScheduledInstanceRecurrence`](crate::types::ScheduledInstanceRecurrence).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ScheduledInstanceRecurrenceBuilder {
     pub(crate) frequency: ::std::option::Option<::std::string::String>,
     pub(crate) interval: ::std::option::Option<i32>,
     pub(crate) occurrence_day_set: ::std::option::Option<::std::vec::Vec<i32>>,
     pub(crate) occurrence_relative_to_end: ::std::option::Option<bool>,
     pub(crate) occurrence_unit: ::std::option::Option<::std::string::String>,
-214
+}
 impl ScheduledInstanceRecurrenceBuilder {
     /// <p>The frequency (<code>Daily</code>, <code>Weekly</code>, or <code>Monthly</code>).</p>
     pub fn frequency(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.frequency = ::std::option::Option::Some(input.into());
         self
-220
+    }
     /// <p>The frequency (<code>Daily</code>, <code>Weekly</code>, or <code>Monthly</code>).</p>
     pub fn set_frequency(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.frequency = input;
         self
-225
+    }
     /// <p>The frequency (<code>Daily</code>, <code>Weekly</code>, or <code>Monthly</code>).</p>
     pub fn get_frequency(&self) -> &::std::option::Option<::std::string::String> {

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

@@ -24,24 +222,223 @@

↥ Expand context

     pub fn interval(&self) -> ::std::option::Option<i32> {
         self.interval
-26
+    }
     /// <p>The days. For a monthly schedule, this is one or more days of the month (1-31). For a weekly schedule, this is one or more days of the week (1-7, where 1 is Sunday). You can't specify this value with a daily schedule. If the occurrence is relative to the end of the month, you can specify only a single day.</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 `.occurrence_days.is_none()`.
     pub fn occurrence_days(&self) -> &[i32] {
         self.occurrence_days.as_deref().unwrap_or_default()
-32
+    }
     /// <p>Indicates whether the occurrence is relative to the end of the specified week or month. You can't specify this value with a daily schedule.</p>
     pub fn occurrence_relative_to_end(&self) -> ::std::option::Option<bool> {
         self.occurrence_relative_to_end
-36
+    }
     /// <p>The unit for <code>OccurrenceDays</code> (<code>DayOfWeek</code> or <code>DayOfMonth</code>). This value is required for a monthly schedule. You can't specify <code>DayOfWeek</code> with a weekly schedule. You can't specify this value with a daily schedule.</p>
     pub fn occurrence_unit(&self) -> ::std::option::Option<&str> {
         self.occurrence_unit.as_deref()
-40
+    }
-41
+}
 static SCHEDULEDINSTANCERECURRENCEREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#ScheduledInstanceRecurrenceRequest",

     "com.amazonaws.ec2",
     "ScheduledInstanceRecurrenceRequest",
 );
 static SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_FREQUENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceRecurrenceRequest$Frequency",
         "com.amazonaws.ec2",
         "ScheduledInstanceRecurrenceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "frequency",
     "Frequency",
 ,
 );
 static SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_INTERVAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceRecurrenceRequest$Interval",
         "com.amazonaws.ec2",
         "ScheduledInstanceRecurrenceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "interval",
     "Interval",
 ,
 );
 static SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_OCCURRENCE_DAYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceRecurrenceRequest$OccurrenceDays",
         "com.amazonaws.ec2",
         "ScheduledInstanceRecurrenceRequest",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "occurrence_days",
     "OccurrenceDays",
 ,
-76
+)
 .with_xml_name("OccurrenceDay");
 static SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_OCCURRENCE_RELATIVE_TO_END: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceRecurrenceRequest$OccurrenceRelativeToEnd",
         "com.amazonaws.ec2",
         "ScheduledInstanceRecurrenceRequest",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "occurrence_relative_to_end",
     "OccurrenceRelativeToEnd",
 ,
 );
 static SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_OCCURRENCE_UNIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstanceRecurrenceRequest$OccurrenceUnit",
         "com.amazonaws.ec2",
         "ScheduledInstanceRecurrenceRequest",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "occurrence_unit",
     "OccurrenceUnit",
 ,
 );
 static SCHEDULEDINSTANCERECURRENCEREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SCHEDULEDINSTANCERECURRENCEREQUEST_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_FREQUENCY,
         &SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_INTERVAL,
         &SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_OCCURRENCE_DAYS,
         &SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_OCCURRENCE_RELATIVE_TO_END,
         &SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_OCCURRENCE_UNIT,
     ],
 );
 impl ScheduledInstanceRecurrenceRequest {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SCHEDULEDINSTANCERECURRENCEREQUEST_SCHEMA;
-112
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ScheduledInstanceRecurrenceRequest {
     #[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.frequency {
             ser.write_string(&SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_FREQUENCY, val)?;
-121
+        }
         if let Some(ref val) = self.interval {
             ser.write_integer(&SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_INTERVAL, *val)?;
-124
+        }
         if let Some(ref val) = self.occurrence_days {
             ser.write_list(
                 &SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_OCCURRENCE_DAYS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_integer(&aws_smithy_schema::prelude::INTEGER, *item)?;
-131
+                    }
                     Ok(())
                 },
             )?;
-135
+        }
         if let Some(ref val) = self.occurrence_relative_to_end {
             ser.write_boolean(&SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_OCCURRENCE_RELATIVE_TO_END, *val)?;
-138
+        }
         if let Some(ref val) = self.occurrence_unit {
             ser.write_string(&SCHEDULEDINSTANCERECURRENCEREQUEST_MEMBER_OCCURRENCE_UNIT, val)?;
-141
+        }
         Ok(())
-143
+    }
-144
+}
 impl ScheduledInstanceRecurrenceRequest {
     /// 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(&SCHEDULEDINSTANCERECURRENCEREQUEST_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SCHEDULEDINSTANCERECURRENCEREQUEST_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.frequency = Some(deser.read_string(member)?);
-163
+                }
                 Some(1) => {
                     builder.interval = Some(deser.read_integer(member)?);
-166
+                }
                 Some(2) => {
                     builder.occurrence_days = 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_integer(member)?);
                             Ok(list)
                         })?
                     });
                     builder.occurrence_days = Some(deser.read_integer_list(member)?);
-169
+                }
                 Some(3) => {
                     builder.occurrence_relative_to_end = Some(deser.read_boolean(member)?);
-172
+                }
                 Some(4) => {
                     builder.occurrence_unit = Some(deser.read_string(member)?);
-175
+                }
                 _ => {}
-177
+            }
             Ok(())
         })?;
         Ok(builder.build())
-181
+    }
-182
+}
 impl ScheduledInstanceRecurrenceRequest {
     /// 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 ScheduledInstanceRecurrenceRequest {
     /// Creates a new builder-style object to manufacture [`ScheduledInstanceRecurrenceRequest`](crate::types::ScheduledInstanceRecurrenceRequest).
     pub fn builder() -> crate::types::builders::ScheduledInstanceRecurrenceRequestBuilder {
         crate::types::builders::ScheduledInstanceRecurrenceRequestBuilder::default()
-198
+    }
-199
+}
-200
 /// A builder for [`ScheduledInstanceRecurrenceRequest`](crate::types::ScheduledInstanceRecurrenceRequest).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ScheduledInstanceRecurrenceRequestBuilder {
     pub(crate) frequency: ::std::option::Option<::std::string::String>,
     pub(crate) interval: ::std::option::Option<i32>,
     pub(crate) occurrence_days: ::std::option::Option<::std::vec::Vec<i32>>,
     pub(crate) occurrence_relative_to_end: ::std::option::Option<bool>,
     pub(crate) occurrence_unit: ::std::option::Option<::std::string::String>,
-210
+}
 impl ScheduledInstanceRecurrenceRequestBuilder {
     /// <p>The frequency (<code>Daily</code>, <code>Weekly</code>, or <code>Monthly</code>).</p>
     pub fn frequency(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.frequency = ::std::option::Option::Some(input.into());
         self
-216
+    }
     /// <p>The frequency (<code>Daily</code>, <code>Weekly</code>, or <code>Monthly</code>).</p>
     pub fn set_frequency(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.frequency = input;
         self
-221
+    }
     /// <p>The frequency (<code>Daily</code>, <code>Weekly</code>, or <code>Monthly</code>).</p>
     pub fn get_frequency(&self) -> &::std::option::Option<::std::string::String> {

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

@@ -18,18 +180,191 @@

↥ Expand context

     /// <p>The device name (for example, <code>/dev/sdh</code> or <code>xvdh</code>).</p>
     pub fn device_name(&self) -> ::std::option::Option<&str> {
         self.device_name.as_deref()
-21
+    }
     /// <p>Parameters used to set up EBS volumes automatically when the instance is launched.</p>
     pub fn ebs(&self) -> ::std::option::Option<&crate::types::ScheduledInstancesEbs> {
         self.ebs.as_ref()
-25
+    }
     /// <p>To omit the device from the block device mapping, specify an empty string.</p>
     pub fn no_device(&self) -> ::std::option::Option<&str> {
         self.no_device.as_deref()
-29
+    }
     /// <p>The virtual device name (<code>ephemeral</code>N). Instance store volumes are numbered starting from 0. An instance type with two available instance store volumes can specify mappings for <code>ephemeral0</code> and <code>ephemeral1</code>. The number of available instance store volumes depends on the instance type. After you connect to the instance, you must mount the volume.</p>
     /// <p>Constraints: For M3 instances, you must specify instance store volumes in the block device mapping for the instance. When you launch an M3 instance, we ignore any instance store volumes specified in the block device mapping for the AMI.</p>
     pub fn virtual_name(&self) -> ::std::option::Option<&str> {
         self.virtual_name.as_deref()
-34
+    }
-35
+}
 static SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#ScheduledInstancesBlockDeviceMapping",

     "com.amazonaws.ec2",
     "ScheduledInstancesBlockDeviceMapping",
 );
 static SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_MEMBER_DEVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstancesBlockDeviceMapping$DeviceName",
         "com.amazonaws.ec2",
         "ScheduledInstancesBlockDeviceMapping",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "device_name",
     "DeviceName",
 ,
 );
 static SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_MEMBER_EBS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstancesBlockDeviceMapping$Ebs",
         "com.amazonaws.ec2",
         "ScheduledInstancesBlockDeviceMapping",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "ebs",
     "Ebs",
 ,
 );
 static SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_MEMBER_NO_DEVICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstancesBlockDeviceMapping$NoDevice",
         "com.amazonaws.ec2",
         "ScheduledInstancesBlockDeviceMapping",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "no_device",
     "NoDevice",
 ,
 );
 static SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_MEMBER_VIRTUAL_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#ScheduledInstancesBlockDeviceMapping$VirtualName",
         "com.amazonaws.ec2",
         "ScheduledInstancesBlockDeviceMapping",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "virtual_name",
     "VirtualName",
 ,
 );
 static SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_MEMBER_DEVICE_NAME,
         &SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_MEMBER_EBS,
         &SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_MEMBER_NO_DEVICE,
         &SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_MEMBER_VIRTUAL_NAME,
     ],
 );
 impl ScheduledInstancesBlockDeviceMapping {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_SCHEMA;
-94
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ScheduledInstancesBlockDeviceMapping {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.device_name {
             ser.write_string(&SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_MEMBER_DEVICE_NAME, val)?;
-103
+        }
         if let Some(ref val) = self.ebs {
             ser.write_struct(&SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_MEMBER_EBS, val)?;
-106
+        }
         if let Some(ref val) = self.no_device {
             ser.write_string(&SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_MEMBER_NO_DEVICE, val)?;
-109
+        }
         if let Some(ref val) = self.virtual_name {
             ser.write_string(&SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_MEMBER_VIRTUAL_NAME, val)?;
-112
+        }
         Ok(())
-114
+    }
-115
+}
 impl ScheduledInstancesBlockDeviceMapping {
     /// 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(&SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SCHEDULEDINSTANCESBLOCKDEVICEMAPPING_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.device_name = Some(deser.read_string(member)?);
-134
+                }
                 Some(1) => {
                     builder.ebs = Some(crate::types::ScheduledInstancesEbs::deserialize(deser)?);
-137
+                }
                 Some(2) => {
                     builder.no_device = Some(deser.read_string(member)?);
-140
+                }
                 Some(3) => {
                     builder.virtual_name = Some(deser.read_string(member)?);
-143
+                }
                 _ => {}
-145
+            }
             Ok(())
         })?;
         Ok(builder.build())
-149
+    }
-150
+}
 impl ScheduledInstancesBlockDeviceMapping {
     /// 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 ScheduledInstancesBlockDeviceMapping {
     /// Creates a new builder-style object to manufacture [`ScheduledInstancesBlockDeviceMapping`](crate::types::ScheduledInstancesBlockDeviceMapping).
     pub fn builder() -> crate::types::builders::ScheduledInstancesBlockDeviceMappingBuilder {
         crate::types::builders::ScheduledInstancesBlockDeviceMappingBuilder::default()
-166
+    }
-167
+}
-168
 /// A builder for [`ScheduledInstancesBlockDeviceMapping`](crate::types::ScheduledInstancesBlockDeviceMapping).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

AWS SDK

Files changed: