AWS SDK

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

@@ -63,63 +244,244 @@

         self.dns_entry.as_ref()
-64
+    }
     /// <p>The private DNS entry of the VPC endpoint association.</p>
     pub fn private_dns_entry(&self) -> ::std::option::Option<&crate::types::DnsEntry> {
         self.private_dns_entry.as_ref()
-68
+    }
     /// <p>The Amazon Resource Name (ARN) of the associated resource.</p>
     pub fn associated_resource_arn(&self) -> ::std::option::Option<&str> {
         self.associated_resource_arn.as_deref()
-72
+    }
     /// <p>The Amazon Resource Name (ARN) of the resource configuration group.</p>
     pub fn resource_configuration_group_arn(&self) -> ::std::option::Option<&str> {
         self.resource_configuration_group_arn.as_deref()
-76
+    }
     /// <p>The tags to apply to the VPC endpoint association.</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()
-82
+    }

-83
+}
 static VPCENDPOINTASSOCIATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpointAssociation", "com.amazonaws.ec2", "VpcEndpointAssociation");
 static VPCENDPOINTASSOCIATION_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointAssociation$Id",
         "com.amazonaws.ec2",
         "VpcEndpointAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "id",
     "Id",
 ,
-95
+)
 .with_xml_name("id");
 static VPCENDPOINTASSOCIATION_MEMBER_VPC_ENDPOINT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointAssociation$VpcEndpointId",
         "com.amazonaws.ec2",
         "VpcEndpointAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpc_endpoint_id",
     "VpcEndpointId",
 ,
-106
+)
 .with_xml_name("vpcEndpointId");
 static VPCENDPOINTASSOCIATION_MEMBER_SERVICE_NETWORK_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointAssociation$ServiceNetworkArn",
         "com.amazonaws.ec2",
         "VpcEndpointAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "service_network_arn",
     "ServiceNetworkArn",
 ,
-117
+)
 .with_xml_name("serviceNetworkArn");
 static VPCENDPOINTASSOCIATION_MEMBER_SERVICE_NETWORK_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointAssociation$ServiceNetworkName",
         "com.amazonaws.ec2",
         "VpcEndpointAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "service_network_name",
     "ServiceNetworkName",
 ,
-128
+)
 .with_xml_name("serviceNetworkName");
 static VPCENDPOINTASSOCIATION_MEMBER_ASSOCIATED_RESOURCE_ACCESSIBILITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointAssociation$AssociatedResourceAccessibility",
         "com.amazonaws.ec2",
         "VpcEndpointAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "associated_resource_accessibility",
     "AssociatedResourceAccessibility",
 ,
-139
+)
 .with_xml_name("associatedResourceAccessibility");
 static VPCENDPOINTASSOCIATION_MEMBER_FAILURE_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointAssociation$FailureReason",
         "com.amazonaws.ec2",
         "VpcEndpointAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "failure_reason",
     "FailureReason",
 ,
-150
+)
 .with_xml_name("failureReason");
 static VPCENDPOINTASSOCIATION_MEMBER_FAILURE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointAssociation$FailureCode",
         "com.amazonaws.ec2",
         "VpcEndpointAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "failure_code",
     "FailureCode",
 ,
-161
+)
 .with_xml_name("failureCode");
 static VPCENDPOINTASSOCIATION_MEMBER_DNS_ENTRY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointAssociation$DnsEntry",
         "com.amazonaws.ec2",
         "VpcEndpointAssociation",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "dns_entry",
     "DnsEntry",
 ,
-172
+)
 .with_xml_name("dnsEntry");
 static VPCENDPOINTASSOCIATION_MEMBER_PRIVATE_DNS_ENTRY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointAssociation$PrivateDnsEntry",
         "com.amazonaws.ec2",
         "VpcEndpointAssociation",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "private_dns_entry",
     "PrivateDnsEntry",
 ,
-183
+)
 .with_xml_name("privateDnsEntry");
 static VPCENDPOINTASSOCIATION_MEMBER_ASSOCIATED_RESOURCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointAssociation$AssociatedResourceArn",
         "com.amazonaws.ec2",
         "VpcEndpointAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "associated_resource_arn",
     "AssociatedResourceArn",
 ,
-194
+)
 .with_xml_name("associatedResourceArn");
 static VPCENDPOINTASSOCIATION_MEMBER_RESOURCE_CONFIGURATION_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointAssociation$ResourceConfigurationGroupArn",
         "com.amazonaws.ec2",
         "VpcEndpointAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_configuration_group_arn",
     "ResourceConfigurationGroupArn",
 ,
-205
+)
 .with_xml_name("resourceConfigurationGroupArn");
 static VPCENDPOINTASSOCIATION_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointAssociation$Tags",
         "com.amazonaws.ec2",
         "VpcEndpointAssociation",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-216
+)
 .with_xml_name("tagSet");
 static VPCENDPOINTASSOCIATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPCENDPOINTASSOCIATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPCENDPOINTASSOCIATION_MEMBER_ID,
         &VPCENDPOINTASSOCIATION_MEMBER_VPC_ENDPOINT_ID,
         &VPCENDPOINTASSOCIATION_MEMBER_SERVICE_NETWORK_ARN,

↧ Expand context

         &VPCENDPOINTASSOCIATION_MEMBER_SERVICE_NETWORK_NAME,
         &VPCENDPOINTASSOCIATION_MEMBER_ASSOCIATED_RESOURCE_ACCESSIBILITY,
         &VPCENDPOINTASSOCIATION_MEMBER_FAILURE_REASON,
         &VPCENDPOINTASSOCIATION_MEMBER_FAILURE_CODE,
         &VPCENDPOINTASSOCIATION_MEMBER_DNS_ENTRY,
         &VPCENDPOINTASSOCIATION_MEMBER_PRIVATE_DNS_ENTRY,
         &VPCENDPOINTASSOCIATION_MEMBER_ASSOCIATED_RESOURCE_ARN,
         &VPCENDPOINTASSOCIATION_MEMBER_RESOURCE_CONFIGURATION_GROUP_ARN,
         &VPCENDPOINTASSOCIATION_MEMBER_TAGS,
     ],
 );
 impl VpcEndpointAssociation {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPCENDPOINTASSOCIATION_SCHEMA;
-239
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpcEndpointAssociation {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,

@@ -265,265 +391,399 @@

↥ Expand context

             ser.write_string(&VPCENDPOINTASSOCIATION_MEMBER_FAILURE_CODE, val)?;
-266
+        }
         if let Some(ref val) = self.dns_entry {
             ser.write_struct(&VPCENDPOINTASSOCIATION_MEMBER_DNS_ENTRY, val)?;
-269
+        }
         if let Some(ref val) = self.private_dns_entry {
             ser.write_struct(&VPCENDPOINTASSOCIATION_MEMBER_PRIVATE_DNS_ENTRY, val)?;
-272
+        }
         if let Some(ref val) = self.associated_resource_arn {
             ser.write_string(&VPCENDPOINTASSOCIATION_MEMBER_ASSOCIATED_RESOURCE_ARN, val)?;
-275
+        }
         if let Some(ref val) = self.resource_configuration_group_arn {
             ser.write_string(&VPCENDPOINTASSOCIATION_MEMBER_RESOURCE_CONFIGURATION_GROUP_ARN, val)?;
-278
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &VPCENDPOINTASSOCIATION_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;

-285
+                    }
                     Ok(())
                 },
             )?;
-289
+        }
         Ok(())
-291
+    }
-292
+}
 impl VpcEndpointAssociation {
     /// 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(&VPCENDPOINTASSOCIATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPCENDPOINTASSOCIATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.id = Some(deser.read_string(member)?);
-311
+                }
                 Some(1) => {
                     builder.vpc_endpoint_id = Some(deser.read_string(member)?);
-314
+                }
                 Some(2) => {
                     builder.service_network_arn = Some(deser.read_string(member)?);
-317
+                }
                 Some(3) => {
                     builder.service_network_name = Some(deser.read_string(member)?);
-320
+                }
                 Some(4) => {
                     builder.associated_resource_accessibility = Some(deser.read_string(member)?);
-323
+                }
                 Some(5) => {
                     builder.failure_reason = Some(deser.read_string(member)?);
-326
+                }
                 Some(6) => {
                     builder.failure_code = Some(deser.read_string(member)?);
-329
+                }
                 Some(7) => {
                     builder.dns_entry = Some(crate::types::DnsEntry::deserialize(deser)?);
-332
+                }
                 Some(8) => {
                     builder.private_dns_entry = Some(crate::types::DnsEntry::deserialize(deser)?);
-335
+                }
                 Some(9) => {
                     builder.associated_resource_arn = Some(deser.read_string(member)?);
-338
+                }
                 Some(10) => {
                     builder.resource_configuration_group_arn = Some(deser.read_string(member)?);
-341
+                }
                 Some(11) => {
                     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
                     });
-351
+                }
                 _ => {}
-353
+            }
             Ok(())
         })?;
         Ok(builder.build())
-357
+    }
-358
+}
 impl VpcEndpointAssociation {
     /// 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 VpcEndpointAssociation {
     /// Creates a new builder-style object to manufacture [`VpcEndpointAssociation`](crate::types::VpcEndpointAssociation).
     pub fn builder() -> crate::types::builders::VpcEndpointAssociationBuilder {
         crate::types::builders::VpcEndpointAssociationBuilder::default()
-374
+    }
-375
+}
-376
 /// A builder for [`VpcEndpointAssociation`](crate::types::VpcEndpointAssociation).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpcEndpointAssociationBuilder {
     pub(crate) id: ::std::option::Option<::std::string::String>,
     pub(crate) vpc_endpoint_id: ::std::option::Option<::std::string::String>,
     pub(crate) service_network_arn: ::std::option::Option<::std::string::String>,
     pub(crate) service_network_name: ::std::option::Option<::std::string::String>,
     pub(crate) associated_resource_accessibility: ::std::option::Option<::std::string::String>,
     pub(crate) failure_reason: ::std::option::Option<::std::string::String>,
     pub(crate) failure_code: ::std::option::Option<::std::string::String>,
     pub(crate) dns_entry: ::std::option::Option<crate::types::DnsEntry>,
     pub(crate) private_dns_entry: ::std::option::Option<crate::types::DnsEntry>,
     pub(crate) associated_resource_arn: ::std::option::Option<::std::string::String>,
     pub(crate) resource_configuration_group_arn: ::std::option::Option<::std::string::String>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-393
+}
 impl VpcEndpointAssociationBuilder {
     /// <p>The ID of the VPC endpoint association.</p>
     pub fn id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.id = ::std::option::Option::Some(input.into());
         self
-399
+    }

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

@@ -69,69 +250,250 @@

↥ Expand context

         self.gateway_load_balancer_arns.as_deref().unwrap_or_default()
-70
+    }
     /// <p>The IP address type for the endpoint.</p>
     pub fn ip_address_type(&self) -> ::std::option::Option<&crate::types::IpAddressType> {
         self.ip_address_type.as_ref()
-74
+    }
     /// <p>The ID of the VPC endpoint connection.</p>
     pub fn vpc_endpoint_connection_id(&self) -> ::std::option::Option<&str> {
         self.vpc_endpoint_connection_id.as_deref()
-78
+    }
     /// <p>The tags.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
     pub fn tags(&self) -> &[crate::types::Tag] {
         self.tags.as_deref().unwrap_or_default()
-84
+    }
     /// <p>The Region of the endpoint.</p>
     pub fn vpc_endpoint_region(&self) -> ::std::option::Option<&str> {
         self.vpc_endpoint_region.as_deref()
-88
+    }

-89
+}
 static VPCENDPOINTCONNECTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpointConnection", "com.amazonaws.ec2", "VpcEndpointConnection");
 static VPCENDPOINTCONNECTION_MEMBER_SERVICE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointConnection$ServiceId",
         "com.amazonaws.ec2",
         "VpcEndpointConnection",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "service_id",
     "ServiceId",
 ,
-101
+)
 .with_xml_name("serviceId");
 static VPCENDPOINTCONNECTION_MEMBER_VPC_ENDPOINT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointConnection$VpcEndpointId",
         "com.amazonaws.ec2",
         "VpcEndpointConnection",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpc_endpoint_id",
     "VpcEndpointId",
 ,
-112
+)
 .with_xml_name("vpcEndpointId");
 static VPCENDPOINTCONNECTION_MEMBER_VPC_ENDPOINT_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointConnection$VpcEndpointOwner",
         "com.amazonaws.ec2",
         "VpcEndpointConnection",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpc_endpoint_owner",
     "VpcEndpointOwner",
 ,
-123
+)
 .with_xml_name("vpcEndpointOwner");
 static VPCENDPOINTCONNECTION_MEMBER_VPC_ENDPOINT_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointConnection$VpcEndpointState",
         "com.amazonaws.ec2",
         "VpcEndpointConnection",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpc_endpoint_state",
     "VpcEndpointState",
 ,
-134
+)
 .with_xml_name("vpcEndpointState");
 static VPCENDPOINTCONNECTION_MEMBER_CREATION_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointConnection$CreationTimestamp",
         "com.amazonaws.ec2",
         "VpcEndpointConnection",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "creation_timestamp",
     "CreationTimestamp",
 ,
-145
+)
 .with_xml_name("creationTimestamp");
 static VPCENDPOINTCONNECTION_MEMBER_DNS_ENTRIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointConnection$DnsEntries",
         "com.amazonaws.ec2",
         "VpcEndpointConnection",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "dns_entries",
     "DnsEntries",
 ,
-156
+)
 .with_xml_name("dnsEntrySet");
 static VPCENDPOINTCONNECTION_MEMBER_NETWORK_LOAD_BALANCER_ARNS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointConnection$NetworkLoadBalancerArns",
         "com.amazonaws.ec2",
         "VpcEndpointConnection",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "network_load_balancer_arns",
     "NetworkLoadBalancerArns",
 ,
-167
+)
 .with_xml_name("networkLoadBalancerArnSet");
 static VPCENDPOINTCONNECTION_MEMBER_GATEWAY_LOAD_BALANCER_ARNS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointConnection$GatewayLoadBalancerArns",
         "com.amazonaws.ec2",
         "VpcEndpointConnection",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "gateway_load_balancer_arns",
     "GatewayLoadBalancerArns",
 ,
-178
+)
 .with_xml_name("gatewayLoadBalancerArnSet");
 static VPCENDPOINTCONNECTION_MEMBER_IP_ADDRESS_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointConnection$IpAddressType",
         "com.amazonaws.ec2",
         "VpcEndpointConnection",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ip_address_type",
     "IpAddressType",
 ,
-189
+)
 .with_xml_name("ipAddressType");
 static VPCENDPOINTCONNECTION_MEMBER_VPC_ENDPOINT_CONNECTION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointConnection$VpcEndpointConnectionId",
         "com.amazonaws.ec2",
         "VpcEndpointConnection",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpc_endpoint_connection_id",
     "VpcEndpointConnectionId",
 ,
-200
+)
 .with_xml_name("vpcEndpointConnectionId");
 static VPCENDPOINTCONNECTION_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointConnection$Tags",
         "com.amazonaws.ec2",
         "VpcEndpointConnection",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-211
+)
 .with_xml_name("tagSet");
 static VPCENDPOINTCONNECTION_MEMBER_VPC_ENDPOINT_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcEndpointConnection$VpcEndpointRegion",
         "com.amazonaws.ec2",
         "VpcEndpointConnection",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpc_endpoint_region",
     "VpcEndpointRegion",
 ,
-222
+)
 .with_xml_name("vpcEndpointRegion");
 static VPCENDPOINTCONNECTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPCENDPOINTCONNECTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPCENDPOINTCONNECTION_MEMBER_SERVICE_ID,
         &VPCENDPOINTCONNECTION_MEMBER_VPC_ENDPOINT_ID,
         &VPCENDPOINTCONNECTION_MEMBER_VPC_ENDPOINT_OWNER,

↧ Expand context

         &VPCENDPOINTCONNECTION_MEMBER_VPC_ENDPOINT_STATE,
         &VPCENDPOINTCONNECTION_MEMBER_CREATION_TIMESTAMP,
         &VPCENDPOINTCONNECTION_MEMBER_DNS_ENTRIES,
         &VPCENDPOINTCONNECTION_MEMBER_NETWORK_LOAD_BALANCER_ARNS,
         &VPCENDPOINTCONNECTION_MEMBER_GATEWAY_LOAD_BALANCER_ARNS,
         &VPCENDPOINTCONNECTION_MEMBER_IP_ADDRESS_TYPE,
         &VPCENDPOINTCONNECTION_MEMBER_VPC_ENDPOINT_CONNECTION_ID,
         &VPCENDPOINTCONNECTION_MEMBER_TAGS,
         &VPCENDPOINTCONNECTION_MEMBER_VPC_ENDPOINT_REGION,
     ],
 );
 impl VpcEndpointConnection {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPCENDPOINTCONNECTION_SCHEMA;
-245
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpcEndpointConnection {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,

@@ -295,295 +451,436 @@

↥ Expand context

-295
+                    }
                     Ok(())
                 },
             )?;
-299
+        }
         if let Some(ref val) = self.ip_address_type {
             ser.write_string(&VPCENDPOINTCONNECTION_MEMBER_IP_ADDRESS_TYPE, val.as_str())?;
-302
+        }
         if let Some(ref val) = self.vpc_endpoint_connection_id {
             ser.write_string(&VPCENDPOINTCONNECTION_MEMBER_VPC_ENDPOINT_CONNECTION_ID, val)?;
-305
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &VPCENDPOINTCONNECTION_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-312
+                    }
                     Ok(())
                 },

             )?;
-316
+        }
         if let Some(ref val) = self.vpc_endpoint_region {
             ser.write_string(&VPCENDPOINTCONNECTION_MEMBER_VPC_ENDPOINT_REGION, val)?;
-319
+        }
         Ok(())
-321
+    }
-322
+}
 impl VpcEndpointConnection {
     /// 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(&VPCENDPOINTCONNECTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPCENDPOINTCONNECTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.service_id = Some(deser.read_string(member)?);
-341
+                }
                 Some(1) => {
                     builder.vpc_endpoint_id = Some(deser.read_string(member)?);
-344
+                }
                 Some(2) => {
                     builder.vpc_endpoint_owner = Some(deser.read_string(member)?);
-347
+                }
                 Some(3) => {
                     builder.vpc_endpoint_state = Some(crate::types::State::from(deser.read_string(member)?.as_str()));
-350
+                }
                 Some(4) => {
                     builder.creation_timestamp = Some(deser.read_timestamp(member)?);
-353
+                }
                 Some(5) => {
                     builder.dns_entries = 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::DnsEntry::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::DnsEntry::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-363
+                }
                 Some(6) => {
                     builder.network_load_balancer_arns = 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.network_load_balancer_arns = Some(deser.read_string_list(member)?);
-366
+                }
                 Some(7) => {
                     builder.gateway_load_balancer_arns = 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.gateway_load_balancer_arns = Some(deser.read_string_list(member)?);
-369
+                }
                 Some(8) => {
                     builder.ip_address_type = Some(crate::types::IpAddressType::from(deser.read_string(member)?.as_str()));
-372
+                }
                 Some(9) => {
                     builder.vpc_endpoint_connection_id = Some(deser.read_string(member)?);
-375
+                }
                 Some(10) => {
                     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
                     });
-385
+                }
                 Some(11) => {
                     builder.vpc_endpoint_region = Some(deser.read_string(member)?);
-388
+                }
                 _ => {}
-390
+            }
             Ok(())
         })?;
         Ok(builder.build())
-394
+    }
-395
+}
 impl VpcEndpointConnection {
     /// 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 VpcEndpointConnection {
     /// Creates a new builder-style object to manufacture [`VpcEndpointConnection`](crate::types::VpcEndpointConnection).
     pub fn builder() -> crate::types::builders::VpcEndpointConnectionBuilder {
         crate::types::builders::VpcEndpointConnectionBuilder::default()
-411
+    }
-412
+}
-413
 /// A builder for [`VpcEndpointConnection`](crate::types::VpcEndpointConnection).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpcEndpointConnectionBuilder {
     pub(crate) service_id: ::std::option::Option<::std::string::String>,
     pub(crate) vpc_endpoint_id: ::std::option::Option<::std::string::String>,
     pub(crate) vpc_endpoint_owner: ::std::option::Option<::std::string::String>,
     pub(crate) vpc_endpoint_state: ::std::option::Option<crate::types::State>,
     pub(crate) creation_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) dns_entries: ::std::option::Option<::std::vec::Vec<crate::types::DnsEntry>>,
     pub(crate) network_load_balancer_arns: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) gateway_load_balancer_arns: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) ip_address_type: ::std::option::Option<crate::types::IpAddressType>,
     pub(crate) vpc_endpoint_connection_id: ::std::option::Option<::std::string::String>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) vpc_endpoint_region: ::std::option::Option<::std::string::String>,
-430
+}
 impl VpcEndpointConnectionBuilder {
     /// <p>The ID of the service to which the endpoint is connected.</p>
     pub fn service_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.service_id = ::std::option::Option::Some(input.into());
         self
-436
+    }

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

@@ -34,34 +254,265 @@

↥ Expand context

-34
+    }
     /// <p>The name of the unique set of Availability Zones, Local Zones, or Wavelength Zones from which Amazon Web Services advertises IP addresses, for example, <code>us-east-1-wl1-bos-wlz-1</code>.</p>
     pub fn network_border_group(&self) -> ::std::option::Option<&str> {
         self.network_border_group.as_deref()
-38
+    }
     /// <p>The ID of the IPv6 address pool from which the IPv6 CIDR block is allocated.</p>
     pub fn ipv6_pool(&self) -> ::std::option::Option<&str> {
         self.ipv6_pool.as_deref()
-42
+    }
     /// <p>Public IPv6 addresses are those advertised on the internet from Amazon Web Services. Private IP addresses are not and cannot be advertised on the internet from Amazon Web Services.</p>
     pub fn ipv6_address_attribute(&self) -> ::std::option::Option<&crate::types::Ipv6AddressAttribute> {
         self.ipv6_address_attribute.as_ref()
-46
+    }
     /// <p>The source that allocated the IP address space. <code>byoip</code> or <code>amazon</code> indicates public IP address space allocated by Amazon or space that you have allocated with Bring your own IP (BYOIP). <code>none</code> indicates private space.</p>
     pub fn ip_source(&self) -> ::std::option::Option<&crate::types::IpSource> {
         self.ip_source.as_ref()
-50
+    }
-51
+}
 static VPCIPV6CIDRBLOCKASSOCIATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#VpcIpv6CidrBlockAssociation",

     "com.amazonaws.ec2",
     "VpcIpv6CidrBlockAssociation",
 );
 static VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_ASSOCIATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcIpv6CidrBlockAssociation$AssociationId",
         "com.amazonaws.ec2",
         "VpcIpv6CidrBlockAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "association_id",
     "AssociationId",
 ,
-66
+)
 .with_xml_name("associationId");
 static VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IPV6_CIDR_BLOCK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcIpv6CidrBlockAssociation$Ipv6CidrBlock",
         "com.amazonaws.ec2",
         "VpcIpv6CidrBlockAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ipv6_cidr_block",
     "Ipv6CidrBlock",
 ,
-77
+)
 .with_xml_name("ipv6CidrBlock");
 static VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IPV6_CIDR_BLOCK_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcIpv6CidrBlockAssociation$Ipv6CidrBlockState",
         "com.amazonaws.ec2",
         "VpcIpv6CidrBlockAssociation",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "ipv6_cidr_block_state",
     "Ipv6CidrBlockState",
 ,
-88
+)
 .with_xml_name("ipv6CidrBlockState");
 static VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_NETWORK_BORDER_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcIpv6CidrBlockAssociation$NetworkBorderGroup",
         "com.amazonaws.ec2",
         "VpcIpv6CidrBlockAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "network_border_group",
     "NetworkBorderGroup",
 ,
-99
+)
 .with_xml_name("networkBorderGroup");
 static VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IPV6_POOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcIpv6CidrBlockAssociation$Ipv6Pool",
         "com.amazonaws.ec2",
         "VpcIpv6CidrBlockAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ipv6_pool",
     "Ipv6Pool",
 ,
-110
+)
 .with_xml_name("ipv6Pool");
 static VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IPV6_ADDRESS_ATTRIBUTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcIpv6CidrBlockAssociation$Ipv6AddressAttribute",
         "com.amazonaws.ec2",
         "VpcIpv6CidrBlockAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ipv6_address_attribute",
     "Ipv6AddressAttribute",
 ,
-121
+)
 .with_xml_name("ipv6AddressAttribute");
 static VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IP_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcIpv6CidrBlockAssociation$IpSource",
         "com.amazonaws.ec2",
         "VpcIpv6CidrBlockAssociation",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ip_source",
     "IpSource",
 ,
-132
+)
 .with_xml_name("ipSource");
 static VPCIPV6CIDRBLOCKASSOCIATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPCIPV6CIDRBLOCKASSOCIATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_ASSOCIATION_ID,
         &VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IPV6_CIDR_BLOCK,
         &VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IPV6_CIDR_BLOCK_STATE,
         &VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_NETWORK_BORDER_GROUP,
         &VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IPV6_POOL,
         &VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IPV6_ADDRESS_ATTRIBUTE,
         &VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IP_SOURCE,
     ],
 );
 impl VpcIpv6CidrBlockAssociation {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPCIPV6CIDRBLOCKASSOCIATION_SCHEMA;
-150
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpcIpv6CidrBlockAssociation {
     #[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.association_id {
             ser.write_string(&VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_ASSOCIATION_ID, val)?;
-159
+        }
         if let Some(ref val) = self.ipv6_cidr_block {
             ser.write_string(&VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IPV6_CIDR_BLOCK, val)?;
-162
+        }
         if let Some(ref val) = self.ipv6_cidr_block_state {
             ser.write_struct(&VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IPV6_CIDR_BLOCK_STATE, val)?;
-165
+        }
         if let Some(ref val) = self.network_border_group {
             ser.write_string(&VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_NETWORK_BORDER_GROUP, val)?;
-168
+        }
         if let Some(ref val) = self.ipv6_pool {
             ser.write_string(&VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IPV6_POOL, val)?;
-171
+        }
         if let Some(ref val) = self.ipv6_address_attribute {
             ser.write_string(&VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IPV6_ADDRESS_ATTRIBUTE, val.as_str())?;
-174
+        }
         if let Some(ref val) = self.ip_source {
             ser.write_string(&VPCIPV6CIDRBLOCKASSOCIATION_MEMBER_IP_SOURCE, val.as_str())?;
-177
+        }
         Ok(())
-179
+    }
-180
+}
 impl VpcIpv6CidrBlockAssociation {
     /// 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(&VPCIPV6CIDRBLOCKASSOCIATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPCIPV6CIDRBLOCKASSOCIATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.association_id = Some(deser.read_string(member)?);
-199
+                }
                 Some(1) => {
                     builder.ipv6_cidr_block = Some(deser.read_string(member)?);
-202
+                }
                 Some(2) => {
                     builder.ipv6_cidr_block_state = Some(crate::types::VpcCidrBlockState::deserialize(deser)?);
-205
+                }
                 Some(3) => {
                     builder.network_border_group = Some(deser.read_string(member)?);
-208
+                }
                 Some(4) => {
                     builder.ipv6_pool = Some(deser.read_string(member)?);
-211
+                }
                 Some(5) => {
                     builder.ipv6_address_attribute = Some(crate::types::Ipv6AddressAttribute::from(deser.read_string(member)?.as_str()));
-214
+                }
                 Some(6) => {
                     builder.ip_source = Some(crate::types::IpSource::from(deser.read_string(member)?.as_str()));
-217
+                }
                 _ => {}
-219
+            }
             Ok(())
         })?;
         Ok(builder.build())
-223
+    }
-224
+}
 impl VpcIpv6CidrBlockAssociation {
     /// 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 VpcIpv6CidrBlockAssociation {
     /// Creates a new builder-style object to manufacture [`VpcIpv6CidrBlockAssociation`](crate::types::VpcIpv6CidrBlockAssociation).
     pub fn builder() -> crate::types::builders::VpcIpv6CidrBlockAssociationBuilder {
         crate::types::builders::VpcIpv6CidrBlockAssociationBuilder::default()
-240
+    }
-241
+}
-242
 /// A builder for [`VpcIpv6CidrBlockAssociation`](crate::types::VpcIpv6CidrBlockAssociation).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpcIpv6CidrBlockAssociationBuilder {
     pub(crate) association_id: ::std::option::Option<::std::string::String>,
     pub(crate) ipv6_cidr_block: ::std::option::Option<::std::string::String>,
     pub(crate) ipv6_cidr_block_state: ::std::option::Option<crate::types::VpcCidrBlockState>,
     pub(crate) network_border_group: ::std::option::Option<::std::string::String>,
     pub(crate) ipv6_pool: ::std::option::Option<::std::string::String>,
     pub(crate) ipv6_address_attribute: ::std::option::Option<crate::types::Ipv6AddressAttribute>,
     pub(crate) ip_source: ::std::option::Option<crate::types::IpSource>,
-254
+}
 impl VpcIpv6CidrBlockAssociationBuilder {
     /// <p>The association ID for the IPv6 CIDR block.</p>
     pub fn association_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.association_id = ::std::option::Option::Some(input.into());
         self
-260
+    }
     /// <p>The association ID for the IPv6 CIDR block.</p>
     pub fn set_association_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.association_id = input;
         self
-265
+    }

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

@@ -27,27 +243,251 @@

↥ Expand context

         self.expiration_time.as_ref()
-28
+    }
     /// <p>Information about the requester VPC. CIDR block information is only returned when describing an active VPC peering connection.</p>
     pub fn requester_vpc_info(&self) -> ::std::option::Option<&crate::types::VpcPeeringConnectionVpcInfo> {
         self.requester_vpc_info.as_ref()
-32
+    }
     /// <p>The status of the VPC peering connection.</p>
     pub fn status(&self) -> ::std::option::Option<&crate::types::VpcPeeringConnectionStateReason> {
         self.status.as_ref()
-36
+    }
     /// <p>Any tags assigned to the resource.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
     pub fn tags(&self) -> &[crate::types::Tag] {
         self.tags.as_deref().unwrap_or_default()
-42
+    }
     /// <p>The ID of the VPC peering connection.</p>
     pub fn vpc_peering_connection_id(&self) -> ::std::option::Option<&str> {
         self.vpc_peering_connection_id.as_deref()
-46
+    }

-47
+}
 static VPCPEERINGCONNECTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcPeeringConnection", "com.amazonaws.ec2", "VpcPeeringConnection");
 static VPCPEERINGCONNECTION_MEMBER_ACCEPTER_VPC_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnection$AccepterVpcInfo",
         "com.amazonaws.ec2",
         "VpcPeeringConnection",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "accepter_vpc_info",
     "AccepterVpcInfo",
 ,
-59
+)
 .with_xml_name("accepterVpcInfo");
 static VPCPEERINGCONNECTION_MEMBER_EXPIRATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnection$ExpirationTime",
         "com.amazonaws.ec2",
         "VpcPeeringConnection",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "expiration_time",
     "ExpirationTime",
 ,
-70
+)
 .with_xml_name("expirationTime");
 static VPCPEERINGCONNECTION_MEMBER_REQUESTER_VPC_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnection$RequesterVpcInfo",
         "com.amazonaws.ec2",
         "VpcPeeringConnection",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "requester_vpc_info",
     "RequesterVpcInfo",
 ,
-81
+)
 .with_xml_name("requesterVpcInfo");
 static VPCPEERINGCONNECTION_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnection$Status",
         "com.amazonaws.ec2",
         "VpcPeeringConnection",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "status",
     "Status",
 ,
-92
+)
 .with_xml_name("status");
 static VPCPEERINGCONNECTION_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcPeeringConnection$Tags", "com.amazonaws.ec2", "VpcPeeringConnection"),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-99
+)
 .with_xml_name("tagSet");
 static VPCPEERINGCONNECTION_MEMBER_VPC_PEERING_CONNECTION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnection$VpcPeeringConnectionId",
         "com.amazonaws.ec2",
         "VpcPeeringConnection",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpc_peering_connection_id",
     "VpcPeeringConnectionId",
 ,
-110
+)
 .with_xml_name("vpcPeeringConnectionId");
 static VPCPEERINGCONNECTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPCPEERINGCONNECTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPCPEERINGCONNECTION_MEMBER_ACCEPTER_VPC_INFO,
         &VPCPEERINGCONNECTION_MEMBER_EXPIRATION_TIME,
         &VPCPEERINGCONNECTION_MEMBER_REQUESTER_VPC_INFO,
         &VPCPEERINGCONNECTION_MEMBER_STATUS,
         &VPCPEERINGCONNECTION_MEMBER_TAGS,
         &VPCPEERINGCONNECTION_MEMBER_VPC_PEERING_CONNECTION_ID,
     ],
 );
 impl VpcPeeringConnection {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPCPEERINGCONNECTION_SCHEMA;
-127
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpcPeeringConnection {
     #[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.accepter_vpc_info {
             ser.write_struct(&VPCPEERINGCONNECTION_MEMBER_ACCEPTER_VPC_INFO, val)?;
-136
+        }
         if let Some(ref val) = self.expiration_time {
             ser.write_timestamp(&VPCPEERINGCONNECTION_MEMBER_EXPIRATION_TIME, val)?;
-139
+        }
         if let Some(ref val) = self.requester_vpc_info {
             ser.write_struct(&VPCPEERINGCONNECTION_MEMBER_REQUESTER_VPC_INFO, val)?;
-142
+        }
         if let Some(ref val) = self.status {
             ser.write_struct(&VPCPEERINGCONNECTION_MEMBER_STATUS, val)?;
-145
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &VPCPEERINGCONNECTION_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-152
+                    }
                     Ok(())
                 },
             )?;
-156
+        }
         if let Some(ref val) = self.vpc_peering_connection_id {
             ser.write_string(&VPCPEERINGCONNECTION_MEMBER_VPC_PEERING_CONNECTION_ID, val)?;
-159
+        }
         Ok(())
-161
+    }
-162
+}
 impl VpcPeeringConnection {
     /// 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(&VPCPEERINGCONNECTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPCPEERINGCONNECTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.accepter_vpc_info = Some(crate::types::VpcPeeringConnectionVpcInfo::deserialize(deser)?);
-181
+                }
                 Some(1) => {
                     builder.expiration_time = Some(deser.read_timestamp(member)?);
-184
+                }
                 Some(2) => {
                     builder.requester_vpc_info = Some(crate::types::VpcPeeringConnectionVpcInfo::deserialize(deser)?);
-187
+                }
                 Some(3) => {
                     builder.status = Some(crate::types::VpcPeeringConnectionStateReason::deserialize(deser)?);
-190
+                }
                 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
                     });
-200
+                }
                 Some(5) => {
                     builder.vpc_peering_connection_id = Some(deser.read_string(member)?);
-203
+                }
                 _ => {}
-205
+            }
             Ok(())
         })?;
         Ok(builder.build())
-209
+    }
-210
+}
 impl VpcPeeringConnection {
     /// 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 VpcPeeringConnection {
     /// Creates a new builder-style object to manufacture [`VpcPeeringConnection`](crate::types::VpcPeeringConnection).
     pub fn builder() -> crate::types::builders::VpcPeeringConnectionBuilder {
         crate::types::builders::VpcPeeringConnectionBuilder::default()
-226
+    }
-227
+}
-228
 /// A builder for [`VpcPeeringConnection`](crate::types::VpcPeeringConnection).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpcPeeringConnectionBuilder {
     pub(crate) accepter_vpc_info: ::std::option::Option<crate::types::VpcPeeringConnectionVpcInfo>,
     pub(crate) expiration_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) requester_vpc_info: ::std::option::Option<crate::types::VpcPeeringConnectionVpcInfo>,
     pub(crate) status: ::std::option::Option<crate::types::VpcPeeringConnectionStateReason>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) vpc_peering_connection_id: ::std::option::Option<::std::string::String>,
-239
+}
 impl VpcPeeringConnectionBuilder {
     /// <p>Information about the accepter VPC. CIDR block information is only returned when describing an active VPC peering connection.</p>
     pub fn accepter_vpc_info(mut self, input: crate::types::VpcPeeringConnectionVpcInfo) -> Self {
         self.accepter_vpc_info = ::std::option::Option::Some(input);
         self
-245
+    }
     /// <p>Information about the accepter VPC. CIDR block information is only returned when describing an active VPC peering connection.</p>
     pub fn set_accepter_vpc_info(mut self, input: ::std::option::Option<crate::types::VpcPeeringConnectionVpcInfo>) -> Self {
         self.accepter_vpc_info = input;
         self
-250
+    }
     /// <p>Information about the accepter VPC. CIDR block information is only returned when describing an active VPC peering connection.</p>

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

@@ -11,11 +167,178 @@

↥ Expand context

     /// <p>Deprecated.</p>
     pub allow_egress_from_local_vpc_to_remote_classic_link: ::std::option::Option<bool>,
-13
+}
 impl VpcPeeringConnectionOptionsDescription {
     /// <p>Indicates whether a local VPC can resolve public DNS hostnames to private IP addresses when queried from instances in a peer VPC.</p>
     pub fn allow_dns_resolution_from_remote_vpc(&self) -> ::std::option::Option<bool> {
         self.allow_dns_resolution_from_remote_vpc
-18
+    }
     /// <p>Deprecated.</p>
     pub fn allow_egress_from_local_classic_link_to_remote_vpc(&self) -> ::std::option::Option<bool> {
         self.allow_egress_from_local_classic_link_to_remote_vpc
-22
+    }
     /// <p>Deprecated.</p>
     pub fn allow_egress_from_local_vpc_to_remote_classic_link(&self) -> ::std::option::Option<bool> {
         self.allow_egress_from_local_vpc_to_remote_classic_link
-26
+    }
-27
+}
 static VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#VpcPeeringConnectionOptionsDescription",
     "com.amazonaws.ec2",

     "VpcPeeringConnectionOptionsDescription",
 );
 static VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_MEMBER_ALLOW_DNS_RESOLUTION_FROM_REMOTE_VPC: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2#VpcPeeringConnectionOptionsDescription$AllowDnsResolutionFromRemoteVpc",
             "com.amazonaws.ec2",
             "VpcPeeringConnectionOptionsDescription",
         ),
         ::aws_smithy_schema::ShapeType::Boolean,
         "allow_dns_resolution_from_remote_vpc",
         "AllowDnsResolutionFromRemoteVpc",
 ,
-43
+    )
     .with_xml_name("allowDnsResolutionFromRemoteVpc");
 static VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_MEMBER_ALLOW_EGRESS_FROM_LOCAL_CLASSIC_LINK_TO_REMOTE_VPC: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2#VpcPeeringConnectionOptionsDescription$AllowEgressFromLocalClassicLinkToRemoteVpc",
             "com.amazonaws.ec2",
             "VpcPeeringConnectionOptionsDescription",
         ),
         ::aws_smithy_schema::ShapeType::Boolean,
         "allow_egress_from_local_classic_link_to_remote_vpc",
         "AllowEgressFromLocalClassicLinkToRemoteVpc",
 ,
-55
+    )
     .with_xml_name("allowEgressFromLocalClassicLinkToRemoteVpc");
 static VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_MEMBER_ALLOW_EGRESS_FROM_LOCAL_VPC_TO_REMOTE_CLASSIC_LINK: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2#VpcPeeringConnectionOptionsDescription$AllowEgressFromLocalVpcToRemoteClassicLink",
             "com.amazonaws.ec2",
             "VpcPeeringConnectionOptionsDescription",
         ),
         ::aws_smithy_schema::ShapeType::Boolean,
         "allow_egress_from_local_vpc_to_remote_classic_link",
         "AllowEgressFromLocalVpcToRemoteClassicLink",
 ,
-67
+    )
     .with_xml_name("allowEgressFromLocalVpcToRemoteClassicLink");
 static VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_MEMBER_ALLOW_DNS_RESOLUTION_FROM_REMOTE_VPC,
         &VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_MEMBER_ALLOW_EGRESS_FROM_LOCAL_CLASSIC_LINK_TO_REMOTE_VPC,
         &VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_MEMBER_ALLOW_EGRESS_FROM_LOCAL_VPC_TO_REMOTE_CLASSIC_LINK,
     ],
 );
 impl VpcPeeringConnectionOptionsDescription {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_SCHEMA;
-81
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpcPeeringConnectionOptionsDescription {
     #[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.allow_dns_resolution_from_remote_vpc {
             ser.write_boolean(&VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_MEMBER_ALLOW_DNS_RESOLUTION_FROM_REMOTE_VPC, *val)?;
-90
+        }
         if let Some(ref val) = self.allow_egress_from_local_classic_link_to_remote_vpc {
             ser.write_boolean(
                 &VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_MEMBER_ALLOW_EGRESS_FROM_LOCAL_CLASSIC_LINK_TO_REMOTE_VPC,
                 *val,
             )?;
-96
+        }
         if let Some(ref val) = self.allow_egress_from_local_vpc_to_remote_classic_link {
             ser.write_boolean(
                 &VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_MEMBER_ALLOW_EGRESS_FROM_LOCAL_VPC_TO_REMOTE_CLASSIC_LINK,
                 *val,
             )?;
-102
+        }
         Ok(())
-104
+    }
-105
+}
 impl VpcPeeringConnectionOptionsDescription {
     /// 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(&VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPCPEERINGCONNECTIONOPTIONSDESCRIPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.allow_dns_resolution_from_remote_vpc = Some(deser.read_boolean(member)?);
-124
+                }
                 Some(1) => {
                     builder.allow_egress_from_local_classic_link_to_remote_vpc = Some(deser.read_boolean(member)?);
-127
+                }
                 Some(2) => {
                     builder.allow_egress_from_local_vpc_to_remote_classic_link = Some(deser.read_boolean(member)?);
-130
+                }
                 _ => {}
-132
+            }
             Ok(())
         })?;
         Ok(builder.build())
-136
+    }
-137
+}
 impl VpcPeeringConnectionOptionsDescription {
     /// 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 VpcPeeringConnectionOptionsDescription {
     /// Creates a new builder-style object to manufacture [`VpcPeeringConnectionOptionsDescription`](crate::types::VpcPeeringConnectionOptionsDescription).
     pub fn builder() -> crate::types::builders::VpcPeeringConnectionOptionsDescriptionBuilder {
         crate::types::builders::VpcPeeringConnectionOptionsDescriptionBuilder::default()
-153
+    }
-154
+}
-155
 /// A builder for [`VpcPeeringConnectionOptionsDescription`](crate::types::VpcPeeringConnectionOptionsDescription).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpcPeeringConnectionOptionsDescriptionBuilder {
     pub(crate) allow_dns_resolution_from_remote_vpc: ::std::option::Option<bool>,
     pub(crate) allow_egress_from_local_classic_link_to_remote_vpc: ::std::option::Option<bool>,
     pub(crate) allow_egress_from_local_vpc_to_remote_classic_link: ::std::option::Option<bool>,
-163
+}
 impl VpcPeeringConnectionOptionsDescriptionBuilder {
     /// <p>Indicates whether a local VPC can resolve public DNS hostnames to private IP addresses when queried from instances in a peer VPC.</p>
     pub fn allow_dns_resolution_from_remote_vpc(mut self, input: bool) -> Self {
         self.allow_dns_resolution_from_remote_vpc = ::std::option::Option::Some(input);
         self
-169
+    }
     /// <p>Indicates whether a local VPC can resolve public DNS hostnames to private IP addresses when queried from instances in a peer VPC.</p>
     pub fn set_allow_dns_resolution_from_remote_vpc(mut self, input: ::std::option::Option<bool>) -> Self {
         self.allow_dns_resolution_from_remote_vpc = input;
         self
-174
+    }
     /// <p>Indicates whether a local VPC can resolve public DNS hostnames to private IP addresses when queried from instances in a peer VPC.</p>
     pub fn get_allow_dns_resolution_from_remote_vpc(&self) -> &::std::option::Option<bool> {
         &self.allow_dns_resolution_from_remote_vpc
-178
+    }

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

@@ -4,4 +136,147 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct VpcPeeringConnectionStateReason {
     /// <p>The status of the VPC peering connection.</p>
     pub code: ::std::option::Option<crate::types::VpcPeeringConnectionStateReasonCode>,
     /// <p>A message that provides more information about the status, if applicable.</p>
     pub message: ::std::option::Option<::std::string::String>,
-11
+}
 impl VpcPeeringConnectionStateReason {
     /// <p>The status of the VPC peering connection.</p>
     pub fn code(&self) -> ::std::option::Option<&crate::types::VpcPeeringConnectionStateReasonCode> {
         self.code.as_ref()
-16
+    }
     /// <p>A message that provides more information about the status, if applicable.</p>
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-20
+    }
-21
+}
 static VPCPEERINGCONNECTIONSTATEREASON_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#VpcPeeringConnectionStateReason",

     "com.amazonaws.ec2",
     "VpcPeeringConnectionStateReason",
 );
 static VPCPEERINGCONNECTIONSTATEREASON_MEMBER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnectionStateReason$Code",
         "com.amazonaws.ec2",
         "VpcPeeringConnectionStateReason",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "code",
     "Code",
 ,
-36
+)
 .with_xml_name("code");
 static VPCPEERINGCONNECTIONSTATEREASON_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnectionStateReason$Message",
         "com.amazonaws.ec2",
         "VpcPeeringConnectionStateReason",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
-47
+)
 .with_xml_name("message");
 static VPCPEERINGCONNECTIONSTATEREASON_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPCPEERINGCONNECTIONSTATEREASON_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPCPEERINGCONNECTIONSTATEREASON_MEMBER_CODE,
         &VPCPEERINGCONNECTIONSTATEREASON_MEMBER_MESSAGE,
     ],
 );
 impl VpcPeeringConnectionStateReason {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPCPEERINGCONNECTIONSTATEREASON_SCHEMA;
-60
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpcPeeringConnectionStateReason {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.code {
             ser.write_string(&VPCPEERINGCONNECTIONSTATEREASON_MEMBER_CODE, val.as_str())?;
-69
+        }
         if let Some(ref val) = self.message {
             ser.write_string(&VPCPEERINGCONNECTIONSTATEREASON_MEMBER_MESSAGE, val)?;
-72
+        }
         Ok(())
-74
+    }
-75
+}
 impl VpcPeeringConnectionStateReason {
     /// 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(&VPCPEERINGCONNECTIONSTATEREASON_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPCPEERINGCONNECTIONSTATEREASON_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.code = Some(crate::types::VpcPeeringConnectionStateReasonCode::from(
                         deser.read_string(member)?.as_str(),
                     ));
-96
+                }
                 Some(1) => {
                     builder.message = Some(deser.read_string(member)?);
-99
+                }
                 _ => {}
-101
+            }
             Ok(())
         })?;
         Ok(builder.build())
-105
+    }
-106
+}
 impl VpcPeeringConnectionStateReason {
     /// 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 VpcPeeringConnectionStateReason {
     /// Creates a new builder-style object to manufacture [`VpcPeeringConnectionStateReason`](crate::types::VpcPeeringConnectionStateReason).
     pub fn builder() -> crate::types::builders::VpcPeeringConnectionStateReasonBuilder {
         crate::types::builders::VpcPeeringConnectionStateReasonBuilder::default()
-122
+    }
-123
+}
-124
 /// A builder for [`VpcPeeringConnectionStateReason`](crate::types::VpcPeeringConnectionStateReason).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpcPeeringConnectionStateReasonBuilder {
     pub(crate) code: ::std::option::Option<crate::types::VpcPeeringConnectionStateReasonCode>,
     pub(crate) message: ::std::option::Option<::std::string::String>,
-131
+}
 impl VpcPeeringConnectionStateReasonBuilder {
     /// <p>The status of the VPC peering connection.</p>
     pub fn code(mut self, input: crate::types::VpcPeeringConnectionStateReasonCode) -> Self {
         self.code = ::std::option::Option::Some(input);
         self
-137
+    }
     /// <p>The status of the VPC peering connection.</p>
     pub fn set_code(mut self, input: ::std::option::Option<crate::types::VpcPeeringConnectionStateReasonCode>) -> Self {
         self.code = input;
         self
-142
+    }
     /// <p>The status of the VPC peering connection.</p>
     pub fn get_code(&self) -> &::std::option::Option<crate::types::VpcPeeringConnectionStateReasonCode> {
         &self.code
-146
+    }
     /// <p>A message that provides more information about the status, if applicable.</p>

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

@@ -38,38 +164,164 @@

↥ Expand context

-38
+    }
     /// <p>The ID of the Amazon Web Services account that owns the VPC.</p>
     pub fn owner_id(&self) -> ::std::option::Option<&str> {
         self.owner_id.as_deref()
-42
+    }
     /// <p>Information about the VPC peering connection options for the accepter or requester VPC.</p>
     pub fn peering_options(&self) -> ::std::option::Option<&crate::types::VpcPeeringConnectionOptionsDescription> {
         self.peering_options.as_ref()
-46
+    }
     /// <p>The ID of the VPC.</p>
     pub fn vpc_id(&self) -> ::std::option::Option<&str> {
         self.vpc_id.as_deref()
-50
+    }
     /// <p>The Region in which the VPC is located.</p>
     pub fn region(&self) -> ::std::option::Option<&str> {
         self.region.as_deref()
-54
+    }
-55
+}
 static VPCPEERINGCONNECTIONVPCINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#VpcPeeringConnectionVpcInfo",

     "com.amazonaws.ec2",
     "VpcPeeringConnectionVpcInfo",
 );
 static VPCPEERINGCONNECTIONVPCINFO_MEMBER_CIDR_BLOCK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnectionVpcInfo$CidrBlock",
         "com.amazonaws.ec2",
         "VpcPeeringConnectionVpcInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "cidr_block",
     "CidrBlock",
 ,
-70
+)
 .with_xml_name("cidrBlock");
 static VPCPEERINGCONNECTIONVPCINFO_MEMBER_IPV6_CIDR_BLOCK_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnectionVpcInfo$Ipv6CidrBlockSet",
         "com.amazonaws.ec2",
         "VpcPeeringConnectionVpcInfo",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "ipv6_cidr_block_set",
     "Ipv6CidrBlockSet",
 ,
-81
+)
 .with_xml_name("ipv6CidrBlockSet");
 static VPCPEERINGCONNECTIONVPCINFO_MEMBER_CIDR_BLOCK_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnectionVpcInfo$CidrBlockSet",
         "com.amazonaws.ec2",
         "VpcPeeringConnectionVpcInfo",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "cidr_block_set",
     "CidrBlockSet",
 ,
-92
+)
 .with_xml_name("cidrBlockSet");
 static VPCPEERINGCONNECTIONVPCINFO_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnectionVpcInfo$OwnerId",
         "com.amazonaws.ec2",
         "VpcPeeringConnectionVpcInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "owner_id",
     "OwnerId",
 ,
-103
+)
 .with_xml_name("ownerId");
 static VPCPEERINGCONNECTIONVPCINFO_MEMBER_PEERING_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnectionVpcInfo$PeeringOptions",
         "com.amazonaws.ec2",
         "VpcPeeringConnectionVpcInfo",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "peering_options",
     "PeeringOptions",
 ,
-114
+)
 .with_xml_name("peeringOptions");
 static VPCPEERINGCONNECTIONVPCINFO_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnectionVpcInfo$VpcId",
         "com.amazonaws.ec2",
         "VpcPeeringConnectionVpcInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpc_id",
     "VpcId",
 ,
-125
+)
 .with_xml_name("vpcId");
 static VPCPEERINGCONNECTIONVPCINFO_MEMBER_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpcPeeringConnectionVpcInfo$Region",
         "com.amazonaws.ec2",
         "VpcPeeringConnectionVpcInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "region",
     "Region",
 ,
-136
+)
 .with_xml_name("region");
 static VPCPEERINGCONNECTIONVPCINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPCPEERINGCONNECTIONVPCINFO_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPCPEERINGCONNECTIONVPCINFO_MEMBER_CIDR_BLOCK,
         &VPCPEERINGCONNECTIONVPCINFO_MEMBER_IPV6_CIDR_BLOCK_SET,
         &VPCPEERINGCONNECTIONVPCINFO_MEMBER_CIDR_BLOCK_SET,

↧ Expand context

         &VPCPEERINGCONNECTIONVPCINFO_MEMBER_OWNER_ID,
         &VPCPEERINGCONNECTIONVPCINFO_MEMBER_PEERING_OPTIONS,
         &VPCPEERINGCONNECTIONVPCINFO_MEMBER_VPC_ID,
         &VPCPEERINGCONNECTIONVPCINFO_MEMBER_REGION,
     ],
 );
 impl VpcPeeringConnectionVpcInfo {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPCPEERINGCONNECTIONVPCINFO_SCHEMA;
-154
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpcPeeringConnectionVpcInfo {
     #[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.cidr_block {
             ser.write_string(&VPCPEERINGCONNECTIONVPCINFO_MEMBER_CIDR_BLOCK, val)?;
-163
+        }
         if let Some(ref val) = self.ipv6_cidr_block_set {

@@ -173,173 +294,299 @@

↥ Expand context

             )?;
-174
+        }
         if let Some(ref val) = self.cidr_block_set {
             ser.write_list(
                 &VPCPEERINGCONNECTIONVPCINFO_MEMBER_CIDR_BLOCK_SET,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::CidrBlock::SCHEMA, item)?;
-181
+                    }
                     Ok(())
                 },
             )?;
-185
+        }
         if let Some(ref val) = self.owner_id {
             ser.write_string(&VPCPEERINGCONNECTIONVPCINFO_MEMBER_OWNER_ID, val)?;
-188
+        }
         if let Some(ref val) = self.peering_options {
             ser.write_struct(&VPCPEERINGCONNECTIONVPCINFO_MEMBER_PEERING_OPTIONS, val)?;
-191
+        }
         if let Some(ref val) = self.vpc_id {

             ser.write_string(&VPCPEERINGCONNECTIONVPCINFO_MEMBER_VPC_ID, val)?;
-194
+        }
         if let Some(ref val) = self.region {
             ser.write_string(&VPCPEERINGCONNECTIONVPCINFO_MEMBER_REGION, val)?;
-197
+        }
         Ok(())
-199
+    }
-200
+}
 impl VpcPeeringConnectionVpcInfo {
     /// 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(&VPCPEERINGCONNECTIONVPCINFO_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPCPEERINGCONNECTIONVPCINFO_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cidr_block = Some(deser.read_string(member)?);
-219
+                }
                 Some(1) => {
                     builder.ipv6_cidr_block_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(crate::types::Ipv6CidrBlock::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Ipv6CidrBlock::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-229
+                }
                 Some(2) => {
                     builder.cidr_block_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(crate::types::CidrBlock::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::CidrBlock::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-239
+                }
                 Some(3) => {
                     builder.owner_id = Some(deser.read_string(member)?);
-242
+                }
                 Some(4) => {
                     builder.peering_options = Some(crate::types::VpcPeeringConnectionOptionsDescription::deserialize(deser)?);
-245
+                }
                 Some(5) => {
                     builder.vpc_id = Some(deser.read_string(member)?);
-248
+                }
                 Some(6) => {
                     builder.region = Some(deser.read_string(member)?);
-251
+                }
                 _ => {}
-253
+            }
             Ok(())
         })?;
         Ok(builder.build())
-257
+    }
-258
+}
 impl VpcPeeringConnectionVpcInfo {
     /// 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 VpcPeeringConnectionVpcInfo {
     /// Creates a new builder-style object to manufacture [`VpcPeeringConnectionVpcInfo`](crate::types::VpcPeeringConnectionVpcInfo).
     pub fn builder() -> crate::types::builders::VpcPeeringConnectionVpcInfoBuilder {
         crate::types::builders::VpcPeeringConnectionVpcInfoBuilder::default()
-274
+    }
-275
+}
-276
 /// A builder for [`VpcPeeringConnectionVpcInfo`](crate::types::VpcPeeringConnectionVpcInfo).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpcPeeringConnectionVpcInfoBuilder {
     pub(crate) cidr_block: ::std::option::Option<::std::string::String>,
     pub(crate) ipv6_cidr_block_set: ::std::option::Option<::std::vec::Vec<crate::types::Ipv6CidrBlock>>,
     pub(crate) cidr_block_set: ::std::option::Option<::std::vec::Vec<crate::types::CidrBlock>>,
     pub(crate) owner_id: ::std::option::Option<::std::string::String>,
     pub(crate) peering_options: ::std::option::Option<crate::types::VpcPeeringConnectionOptionsDescription>,
     pub(crate) vpc_id: ::std::option::Option<::std::string::String>,
     pub(crate) region: ::std::option::Option<::std::string::String>,
-288
+}
 impl VpcPeeringConnectionVpcInfoBuilder {
     /// <p>The IPv4 CIDR block for the VPC.</p>
     pub fn cidr_block(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.cidr_block = ::std::option::Option::Some(input.into());
         self
-294
+    }
     /// <p>The IPv4 CIDR block for the VPC.</p>
     pub fn set_cidr_block(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.cidr_block = input;
         self
-299
+    }

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

@@ -109,109 +286,286 @@

↥ Expand context

         self.vpn_gateway_id.as_deref()
-110
+    }
-111
+}
 impl ::std::fmt::Debug for VpnConnection {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("VpnConnection");
         formatter.field("category", &self.category);
         formatter.field("transit_gateway_id", &self.transit_gateway_id);
         formatter.field("core_network_arn", &self.core_network_arn);
         formatter.field("core_network_attachment_arn", &self.core_network_attachment_arn);
         formatter.field("gateway_association_state", &self.gateway_association_state);
         formatter.field("options", &self.options);
         formatter.field("routes", &self.routes);
         formatter.field("tags", &self.tags);
         formatter.field("vgw_telemetry", &self.vgw_telemetry);
         formatter.field("pre_shared_key_arn", &self.pre_shared_key_arn);
         formatter.field("vpn_connection_id", &self.vpn_connection_id);
         formatter.field("state", &self.state);
         formatter.field("customer_gateway_configuration", &"*** Sensitive Data Redacted ***");
         formatter.field("r#type", &self.r#type);

         formatter.field("customer_gateway_id", &self.customer_gateway_id);
         formatter.field("vpn_gateway_id", &self.vpn_gateway_id);
         formatter.finish()
-132
+    }
-133
+}
 static VPNCONNECTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection", "com.amazonaws.ec2", "VpnConnection");
 static VPNCONNECTION_MEMBER_CATEGORY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection$Category", "com.amazonaws.ec2", "VpnConnection"),
     ::aws_smithy_schema::ShapeType::String,
     "category",
     "Category",
 ,
-141
+)
 .with_xml_name("category");
 static VPNCONNECTION_MEMBER_TRANSIT_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection$TransitGatewayId", "com.amazonaws.ec2", "VpnConnection"),
     ::aws_smithy_schema::ShapeType::String,
     "transit_gateway_id",
     "TransitGatewayId",
 ,
-148
+)
 .with_xml_name("transitGatewayId");
 static VPNCONNECTION_MEMBER_CORE_NETWORK_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection$CoreNetworkArn", "com.amazonaws.ec2", "VpnConnection"),
     ::aws_smithy_schema::ShapeType::String,
     "core_network_arn",
     "CoreNetworkArn",
 ,
-155
+)
 .with_xml_name("coreNetworkArn");
 static VPNCONNECTION_MEMBER_CORE_NETWORK_ATTACHMENT_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnection$CoreNetworkAttachmentArn",
         "com.amazonaws.ec2",
         "VpnConnection",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "core_network_attachment_arn",
     "CoreNetworkAttachmentArn",
 ,
-166
+)
 .with_xml_name("coreNetworkAttachmentArn");
 static VPNCONNECTION_MEMBER_GATEWAY_ASSOCIATION_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnection$GatewayAssociationState",
         "com.amazonaws.ec2",
         "VpnConnection",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "gateway_association_state",
     "GatewayAssociationState",
 ,
-177
+)
 .with_xml_name("gatewayAssociationState");
 static VPNCONNECTION_MEMBER_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection$Options", "com.amazonaws.ec2", "VpnConnection"),
     ::aws_smithy_schema::ShapeType::Structure,
     "options",
     "Options",
 ,
-184
+)
 .with_xml_name("options");
 static VPNCONNECTION_MEMBER_ROUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection$Routes", "com.amazonaws.ec2", "VpnConnection"),
     ::aws_smithy_schema::ShapeType::List,
     "routes",
     "Routes",
 ,
-191
+)
 .with_xml_name("routes");
 static VPNCONNECTION_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection$Tags", "com.amazonaws.ec2", "VpnConnection"),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-198
+)
 .with_xml_name("tagSet");
 static VPNCONNECTION_MEMBER_VGW_TELEMETRY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection$VgwTelemetry", "com.amazonaws.ec2", "VpnConnection"),
     ::aws_smithy_schema::ShapeType::List,
     "vgw_telemetry",
     "VgwTelemetry",
 ,
-205
+)
 .with_xml_name("vgwTelemetry");
 static VPNCONNECTION_MEMBER_PRE_SHARED_KEY_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection$PreSharedKeyArn", "com.amazonaws.ec2", "VpnConnection"),
     ::aws_smithy_schema::ShapeType::String,
     "pre_shared_key_arn",
     "PreSharedKeyArn",
 ,
-212
+)
 .with_xml_name("preSharedKeyArn");
 static VPNCONNECTION_MEMBER_VPN_CONNECTION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection$VpnConnectionId", "com.amazonaws.ec2", "VpnConnection"),
     ::aws_smithy_schema::ShapeType::String,
     "vpn_connection_id",
     "VpnConnectionId",
 ,
-219
+)
 .with_xml_name("vpnConnectionId");
 static VPNCONNECTION_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection$State", "com.amazonaws.ec2", "VpnConnection"),
     ::aws_smithy_schema::ShapeType::String,
     "state",
     "State",
 ,
-226
+)
 .with_xml_name("state");
 static VPNCONNECTION_MEMBER_CUSTOMER_GATEWAY_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnection$CustomerGatewayConfiguration",
         "com.amazonaws.ec2",
         "VpnConnection",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "customer_gateway_configuration",
     "CustomerGatewayConfiguration",
 ,
-237
+)
 .with_xml_name("customerGatewayConfiguration");
 static VPNCONNECTION_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection$Type", "com.amazonaws.ec2", "VpnConnection"),
     ::aws_smithy_schema::ShapeType::String,
     "r##type",
     "Type",
 ,
-244
+)
 .with_xml_name("type");
 static VPNCONNECTION_MEMBER_CUSTOMER_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection$CustomerGatewayId", "com.amazonaws.ec2", "VpnConnection"),
     ::aws_smithy_schema::ShapeType::String,
     "customer_gateway_id",
     "CustomerGatewayId",
 ,
-251
+)
 .with_xml_name("customerGatewayId");
 static VPNCONNECTION_MEMBER_VPN_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnection$VpnGatewayId", "com.amazonaws.ec2", "VpnConnection"),
     ::aws_smithy_schema::ShapeType::String,
     "vpn_gateway_id",
     "VpnGatewayId",
 ,
-258
+)
 .with_xml_name("vpnGatewayId");
 static VPNCONNECTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPNCONNECTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPNCONNECTION_MEMBER_CATEGORY,
         &VPNCONNECTION_MEMBER_TRANSIT_GATEWAY_ID,
         &VPNCONNECTION_MEMBER_CORE_NETWORK_ARN,

↧ Expand context

         &VPNCONNECTION_MEMBER_CORE_NETWORK_ATTACHMENT_ARN,
         &VPNCONNECTION_MEMBER_GATEWAY_ASSOCIATION_STATE,
         &VPNCONNECTION_MEMBER_OPTIONS,
         &VPNCONNECTION_MEMBER_ROUTES,
         &VPNCONNECTION_MEMBER_TAGS,
         &VPNCONNECTION_MEMBER_VGW_TELEMETRY,
         &VPNCONNECTION_MEMBER_PRE_SHARED_KEY_ARN,
         &VPNCONNECTION_MEMBER_VPN_CONNECTION_ID,
         &VPNCONNECTION_MEMBER_STATE,
         &VPNCONNECTION_MEMBER_CUSTOMER_GATEWAY_CONFIGURATION,
         &VPNCONNECTION_MEMBER_TYPE,
         &VPNCONNECTION_MEMBER_CUSTOMER_GATEWAY_ID,
         &VPNCONNECTION_MEMBER_VPN_GATEWAY_ID,
     ],
 );
 impl VpnConnection {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPNCONNECTION_SCHEMA;
-285
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpnConnection {

@@ -339,339 +497,499 @@

↥ Expand context

                     Ok(())
                 },
             )?;
-342
+        }
         if let Some(ref val) = self.pre_shared_key_arn {
             ser.write_string(&VPNCONNECTION_MEMBER_PRE_SHARED_KEY_ARN, val)?;
-345
+        }
         if let Some(ref val) = self.vpn_connection_id {
             ser.write_string(&VPNCONNECTION_MEMBER_VPN_CONNECTION_ID, val)?;
-348
+        }
         if let Some(ref val) = self.state {
             ser.write_string(&VPNCONNECTION_MEMBER_STATE, val.as_str())?;
-351
+        }
         if let Some(ref val) = self.customer_gateway_configuration {
             ser.write_string(&VPNCONNECTION_MEMBER_CUSTOMER_GATEWAY_CONFIGURATION, val)?;
-354
+        }
         if let Some(ref val) = self.r#type {
             ser.write_string(&VPNCONNECTION_MEMBER_TYPE, val.as_str())?;
-357
+        }
         if let Some(ref val) = self.customer_gateway_id {

             ser.write_string(&VPNCONNECTION_MEMBER_CUSTOMER_GATEWAY_ID, val)?;
-360
+        }
         if let Some(ref val) = self.vpn_gateway_id {
             ser.write_string(&VPNCONNECTION_MEMBER_VPN_GATEWAY_ID, val)?;
-363
+        }
         Ok(())
-365
+    }
-366
+}
 impl VpnConnection {
     /// 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(&VPNCONNECTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPNCONNECTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.category = Some(deser.read_string(member)?);
-385
+                }
                 Some(1) => {
                     builder.transit_gateway_id = Some(deser.read_string(member)?);
-388
+                }
                 Some(2) => {
                     builder.core_network_arn = Some(deser.read_string(member)?);
-391
+                }
                 Some(3) => {
                     builder.core_network_attachment_arn = Some(deser.read_string(member)?);
-394
+                }
                 Some(4) => {
                     builder.gateway_association_state = Some(crate::types::GatewayAssociationState::from(deser.read_string(member)?.as_str()));
-397
+                }
                 Some(5) => {
                     builder.options = Some(crate::types::VpnConnectionOptions::deserialize(deser)?);
-400
+                }
                 Some(6) => {
                     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::VpnStaticRoute::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::VpnStaticRoute::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-410
+                }
                 Some(7) => {
                     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
                     });
-420
+                }
                 Some(8) => {
                     builder.vgw_telemetry = 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::VgwTelemetry::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::VgwTelemetry::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-430
+                }
                 Some(9) => {
                     builder.pre_shared_key_arn = Some(deser.read_string(member)?);
-433
+                }
                 Some(10) => {
                     builder.vpn_connection_id = Some(deser.read_string(member)?);
-436
+                }
                 Some(11) => {
                     builder.state = Some(crate::types::VpnState::from(deser.read_string(member)?.as_str()));
-439
+                }
                 Some(12) => {
                     builder.customer_gateway_configuration = Some(deser.read_string(member)?);
-442
+                }
                 Some(13) => {
                     builder.r#type = Some(crate::types::GatewayType::from(deser.read_string(member)?.as_str()));
-445
+                }
                 Some(14) => {
                     builder.customer_gateway_id = Some(deser.read_string(member)?);
-448
+                }
                 Some(15) => {
                     builder.vpn_gateway_id = Some(deser.read_string(member)?);
-451
+                }
                 _ => {}
-453
+            }
             Ok(())
         })?;
         Ok(builder.build())
-457
+    }
-458
+}
 impl VpnConnection {
     /// 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 VpnConnection {
     /// Creates a new builder-style object to manufacture [`VpnConnection`](crate::types::VpnConnection).
     pub fn builder() -> crate::types::builders::VpnConnectionBuilder {
         crate::types::builders::VpnConnectionBuilder::default()
-474
+    }
-475
+}
-476
 /// A builder for [`VpnConnection`](crate::types::VpnConnection).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpnConnectionBuilder {
     pub(crate) category: ::std::option::Option<::std::string::String>,
     pub(crate) transit_gateway_id: ::std::option::Option<::std::string::String>,
     pub(crate) core_network_arn: ::std::option::Option<::std::string::String>,
     pub(crate) core_network_attachment_arn: ::std::option::Option<::std::string::String>,
     pub(crate) gateway_association_state: ::std::option::Option<crate::types::GatewayAssociationState>,
     pub(crate) options: ::std::option::Option<crate::types::VpnConnectionOptions>,
     pub(crate) routes: ::std::option::Option<::std::vec::Vec<crate::types::VpnStaticRoute>>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) vgw_telemetry: ::std::option::Option<::std::vec::Vec<crate::types::VgwTelemetry>>,
     pub(crate) pre_shared_key_arn: ::std::option::Option<::std::string::String>,
     pub(crate) vpn_connection_id: ::std::option::Option<::std::string::String>,
     pub(crate) state: ::std::option::Option<crate::types::VpnState>,
     pub(crate) customer_gateway_configuration: ::std::option::Option<::std::string::String>,
     pub(crate) r#type: ::std::option::Option<crate::types::GatewayType>,
     pub(crate) customer_gateway_id: ::std::option::Option<::std::string::String>,
     pub(crate) vpn_gateway_id: ::std::option::Option<::std::string::String>,
-497
+}
 impl VpnConnectionBuilder {
     /// <p>The category of the VPN connection. A value of <code>VPN</code> indicates an Amazon Web Services VPN connection. A value of <code>VPN-Classic</code> indicates an Amazon Web Services Classic VPN connection.</p>

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

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

↥ Expand context

 impl VpnConnectionDeviceType {
     /// <p>Customer gateway device identifier.</p>
     pub fn vpn_connection_device_type_id(&self) -> ::std::option::Option<&str> {
         self.vpn_connection_device_type_id.as_deref()
-20
+    }
     /// <p>Customer gateway device vendor.</p>
     pub fn vendor(&self) -> ::std::option::Option<&str> {
         self.vendor.as_deref()
-24
+    }
     /// <p>Customer gateway device platform.</p>
     pub fn platform(&self) -> ::std::option::Option<&str> {
         self.platform.as_deref()
-28
+    }
     /// <p>Customer gateway device software version.</p>
     pub fn software(&self) -> ::std::option::Option<&str> {
         self.software.as_deref()
-32
+    }
-33
+}
 static VPNCONNECTIONDEVICETYPE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#VpnConnectionDeviceType",

     "com.amazonaws.ec2",
     "VpnConnectionDeviceType",
 );
 static VPNCONNECTIONDEVICETYPE_MEMBER_VPN_CONNECTION_DEVICE_TYPE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionDeviceType$VpnConnectionDeviceTypeId",
         "com.amazonaws.ec2",
         "VpnConnectionDeviceType",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpn_connection_device_type_id",
     "VpnConnectionDeviceTypeId",
 ,
-48
+)
 .with_xml_name("vpnConnectionDeviceTypeId");
 static VPNCONNECTIONDEVICETYPE_MEMBER_VENDOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionDeviceType$Vendor",
         "com.amazonaws.ec2",
         "VpnConnectionDeviceType",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vendor",
     "Vendor",
 ,
-59
+)
 .with_xml_name("vendor");
 static VPNCONNECTIONDEVICETYPE_MEMBER_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionDeviceType$Platform",
         "com.amazonaws.ec2",
         "VpnConnectionDeviceType",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "platform",
     "Platform",
 ,
-70
+)
 .with_xml_name("platform");
 static VPNCONNECTIONDEVICETYPE_MEMBER_SOFTWARE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionDeviceType$Software",
         "com.amazonaws.ec2",
         "VpnConnectionDeviceType",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "software",
     "Software",
 ,
-81
+)
 .with_xml_name("software");
 static VPNCONNECTIONDEVICETYPE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPNCONNECTIONDEVICETYPE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPNCONNECTIONDEVICETYPE_MEMBER_VPN_CONNECTION_DEVICE_TYPE_ID,
         &VPNCONNECTIONDEVICETYPE_MEMBER_VENDOR,
         &VPNCONNECTIONDEVICETYPE_MEMBER_PLATFORM,
         &VPNCONNECTIONDEVICETYPE_MEMBER_SOFTWARE,
     ],
 );
 impl VpnConnectionDeviceType {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPNCONNECTIONDEVICETYPE_SCHEMA;
-96
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpnConnectionDeviceType {
     #[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.vpn_connection_device_type_id {
             ser.write_string(&VPNCONNECTIONDEVICETYPE_MEMBER_VPN_CONNECTION_DEVICE_TYPE_ID, val)?;
-105
+        }
         if let Some(ref val) = self.vendor {
             ser.write_string(&VPNCONNECTIONDEVICETYPE_MEMBER_VENDOR, val)?;
-108
+        }
         if let Some(ref val) = self.platform {
             ser.write_string(&VPNCONNECTIONDEVICETYPE_MEMBER_PLATFORM, val)?;
-111
+        }
         if let Some(ref val) = self.software {
             ser.write_string(&VPNCONNECTIONDEVICETYPE_MEMBER_SOFTWARE, val)?;
-114
+        }
         Ok(())
-116
+    }
-117
+}
 impl VpnConnectionDeviceType {
     /// 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(&VPNCONNECTIONDEVICETYPE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPNCONNECTIONDEVICETYPE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.vpn_connection_device_type_id = Some(deser.read_string(member)?);
-136
+                }
                 Some(1) => {
                     builder.vendor = Some(deser.read_string(member)?);
-139
+                }
                 Some(2) => {
                     builder.platform = Some(deser.read_string(member)?);
-142
+                }
                 Some(3) => {
                     builder.software = Some(deser.read_string(member)?);
-145
+                }
                 _ => {}
-147
+            }
             Ok(())
         })?;
         Ok(builder.build())
-151
+    }
-152
+}
 impl VpnConnectionDeviceType {
     /// 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 VpnConnectionDeviceType {
     /// Creates a new builder-style object to manufacture [`VpnConnectionDeviceType`](crate::types::VpnConnectionDeviceType).
     pub fn builder() -> crate::types::builders::VpnConnectionDeviceTypeBuilder {
         crate::types::builders::VpnConnectionDeviceTypeBuilder::default()
-168
+    }
-169
+}
-170
 /// A builder for [`VpnConnectionDeviceType`](crate::types::VpnConnectionDeviceType).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpnConnectionDeviceTypeBuilder {
     pub(crate) vpn_connection_device_type_id: ::std::option::Option<::std::string::String>,
     pub(crate) vendor: ::std::option::Option<::std::string::String>,
     pub(crate) platform: ::std::option::Option<::std::string::String>,
     pub(crate) software: ::std::option::Option<::std::string::String>,
-179
+}
 impl VpnConnectionDeviceTypeBuilder {
     /// <p>Customer gateway device identifier.</p>
     pub fn vpn_connection_device_type_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.vpn_connection_device_type_id = ::std::option::Option::Some(input.into());
         self
-185
+    }
     /// <p>Customer gateway device identifier.</p>
     pub fn set_vpn_connection_device_type_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.vpn_connection_device_type_id = input;
         self
-190
+    }
     /// <p>Customer gateway device identifier.</p>
     pub fn get_vpn_connection_device_type_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.vpn_connection_device_type_id

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

@@ -55,55 +214,214 @@

↥ Expand context

     /// <p>The type of IPv4 address assigned to the outside interface of the customer gateway.</p>
     /// <p>Valid values: <code>PrivateIpv4</code> | <code>PublicIpv4</code> | <code>Ipv6</code></p>
     /// <p>Default: <code>PublicIpv4</code></p>
     pub fn outside_ip_address_type(&self) -> ::std::option::Option<&str> {
         self.outside_ip_address_type.as_deref()
-60
+    }
     /// <p>The transit gateway attachment ID in use for the VPN tunnel.</p>
     pub fn transport_transit_gateway_attachment_id(&self) -> ::std::option::Option<&str> {
         self.transport_transit_gateway_attachment_id.as_deref()
-64
+    }
     /// <p>Indicates whether the VPN tunnels process IPv4 or IPv6 traffic.</p>
     pub fn tunnel_inside_ip_version(&self) -> ::std::option::Option<&crate::types::TunnelInsideIpVersion> {
         self.tunnel_inside_ip_version.as_ref()
-68
+    }
     /// <p>Indicates the VPN tunnel 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 `.tunnel_options.is_none()`.
     pub fn tunnel_options(&self) -> &[crate::types::TunnelOption] {
         self.tunnel_options.as_deref().unwrap_or_default()
-74
+    }

-75
+}
 static VPNCONNECTIONOPTIONS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnConnectionOptions", "com.amazonaws.ec2", "VpnConnectionOptions");
 static VPNCONNECTIONOPTIONS_MEMBER_ENABLE_ACCELERATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptions$EnableAcceleration",
         "com.amazonaws.ec2",
         "VpnConnectionOptions",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "enable_acceleration",
     "EnableAcceleration",
 ,
-87
+)
 .with_xml_name("enableAcceleration");
 static VPNCONNECTIONOPTIONS_MEMBER_STATIC_ROUTES_ONLY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptions$StaticRoutesOnly",
         "com.amazonaws.ec2",
         "VpnConnectionOptions",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "static_routes_only",
     "StaticRoutesOnly",
 ,
-98
+)
 .with_xml_name("staticRoutesOnly");
 static VPNCONNECTIONOPTIONS_MEMBER_LOCAL_IPV4_NETWORK_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptions$LocalIpv4NetworkCidr",
         "com.amazonaws.ec2",
         "VpnConnectionOptions",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "local_ipv4_network_cidr",
     "LocalIpv4NetworkCidr",
 ,
-109
+)
 .with_xml_name("localIpv4NetworkCidr");
 static VPNCONNECTIONOPTIONS_MEMBER_REMOTE_IPV4_NETWORK_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptions$RemoteIpv4NetworkCidr",
         "com.amazonaws.ec2",
         "VpnConnectionOptions",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "remote_ipv4_network_cidr",
     "RemoteIpv4NetworkCidr",
 ,
-120
+)
 .with_xml_name("remoteIpv4NetworkCidr");
 static VPNCONNECTIONOPTIONS_MEMBER_LOCAL_IPV6_NETWORK_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptions$LocalIpv6NetworkCidr",
         "com.amazonaws.ec2",
         "VpnConnectionOptions",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "local_ipv6_network_cidr",
     "LocalIpv6NetworkCidr",
 ,
-131
+)
 .with_xml_name("localIpv6NetworkCidr");
 static VPNCONNECTIONOPTIONS_MEMBER_REMOTE_IPV6_NETWORK_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptions$RemoteIpv6NetworkCidr",
         "com.amazonaws.ec2",
         "VpnConnectionOptions",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "remote_ipv6_network_cidr",
     "RemoteIpv6NetworkCidr",
 ,
-142
+)
 .with_xml_name("remoteIpv6NetworkCidr");
 static VPNCONNECTIONOPTIONS_MEMBER_OUTSIDE_IP_ADDRESS_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptions$OutsideIpAddressType",
         "com.amazonaws.ec2",
         "VpnConnectionOptions",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "outside_ip_address_type",
     "OutsideIpAddressType",
 ,
-153
+)
 .with_xml_name("outsideIpAddressType");
 static VPNCONNECTIONOPTIONS_MEMBER_TRANSPORT_TRANSIT_GATEWAY_ATTACHMENT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptions$TransportTransitGatewayAttachmentId",
         "com.amazonaws.ec2",
         "VpnConnectionOptions",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "transport_transit_gateway_attachment_id",
     "TransportTransitGatewayAttachmentId",
 ,
-164
+)
 .with_xml_name("transportTransitGatewayAttachmentId");
 static VPNCONNECTIONOPTIONS_MEMBER_TUNNEL_INSIDE_IP_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptions$TunnelInsideIpVersion",
         "com.amazonaws.ec2",
         "VpnConnectionOptions",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "tunnel_inside_ip_version",
     "TunnelInsideIpVersion",
 ,
-175
+)
 .with_xml_name("tunnelInsideIpVersion");
 static VPNCONNECTIONOPTIONS_MEMBER_TUNNEL_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptions$TunnelOptions",
         "com.amazonaws.ec2",
         "VpnConnectionOptions",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tunnel_options",
     "TunnelOptions",
 ,
-186
+)
 .with_xml_name("tunnelOptionSet");
 static VPNCONNECTIONOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPNCONNECTIONOPTIONS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPNCONNECTIONOPTIONS_MEMBER_ENABLE_ACCELERATION,
         &VPNCONNECTIONOPTIONS_MEMBER_STATIC_ROUTES_ONLY,
         &VPNCONNECTIONOPTIONS_MEMBER_LOCAL_IPV4_NETWORK_CIDR,

↧ Expand context

         &VPNCONNECTIONOPTIONS_MEMBER_REMOTE_IPV4_NETWORK_CIDR,
         &VPNCONNECTIONOPTIONS_MEMBER_LOCAL_IPV6_NETWORK_CIDR,
         &VPNCONNECTIONOPTIONS_MEMBER_REMOTE_IPV6_NETWORK_CIDR,
         &VPNCONNECTIONOPTIONS_MEMBER_OUTSIDE_IP_ADDRESS_TYPE,
         &VPNCONNECTIONOPTIONS_MEMBER_TRANSPORT_TRANSIT_GATEWAY_ATTACHMENT_ID,
         &VPNCONNECTIONOPTIONS_MEMBER_TUNNEL_INSIDE_IP_VERSION,
         &VPNCONNECTIONOPTIONS_MEMBER_TUNNEL_OPTIONS,
     ],
 );
 impl VpnConnectionOptions {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPNCONNECTIONOPTIONS_SCHEMA;
-207
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpnConnectionOptions {
     #[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.enable_acceleration {

@@ -227,227 +347,355 @@

↥ Expand context

             ser.write_string(&VPNCONNECTIONOPTIONS_MEMBER_LOCAL_IPV6_NETWORK_CIDR, val)?;
-228
+        }
         if let Some(ref val) = self.remote_ipv6_network_cidr {
             ser.write_string(&VPNCONNECTIONOPTIONS_MEMBER_REMOTE_IPV6_NETWORK_CIDR, val)?;
-231
+        }
         if let Some(ref val) = self.outside_ip_address_type {
             ser.write_string(&VPNCONNECTIONOPTIONS_MEMBER_OUTSIDE_IP_ADDRESS_TYPE, val)?;
-234
+        }
         if let Some(ref val) = self.transport_transit_gateway_attachment_id {
             ser.write_string(&VPNCONNECTIONOPTIONS_MEMBER_TRANSPORT_TRANSIT_GATEWAY_ATTACHMENT_ID, val)?;
-237
+        }
         if let Some(ref val) = self.tunnel_inside_ip_version {
             ser.write_string(&VPNCONNECTIONOPTIONS_MEMBER_TUNNEL_INSIDE_IP_VERSION, val.as_str())?;
-240
+        }
         if let Some(ref val) = self.tunnel_options {
             ser.write_list(
                 &VPNCONNECTIONOPTIONS_MEMBER_TUNNEL_OPTIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TunnelOption::SCHEMA, item)?;

-247
+                    }
                     Ok(())
                 },
             )?;
-251
+        }
         Ok(())
-253
+    }
-254
+}
 impl VpnConnectionOptions {
     /// 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(&VPNCONNECTIONOPTIONS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPNCONNECTIONOPTIONS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.enable_acceleration = Some(deser.read_boolean(member)?);
-273
+                }
                 Some(1) => {
                     builder.static_routes_only = Some(deser.read_boolean(member)?);
-276
+                }
                 Some(2) => {
                     builder.local_ipv4_network_cidr = Some(deser.read_string(member)?);
-279
+                }
                 Some(3) => {
                     builder.remote_ipv4_network_cidr = Some(deser.read_string(member)?);
-282
+                }
                 Some(4) => {
                     builder.local_ipv6_network_cidr = Some(deser.read_string(member)?);
-285
+                }
                 Some(5) => {
                     builder.remote_ipv6_network_cidr = Some(deser.read_string(member)?);
-288
+                }
                 Some(6) => {
                     builder.outside_ip_address_type = Some(deser.read_string(member)?);
-291
+                }
                 Some(7) => {
                     builder.transport_transit_gateway_attachment_id = Some(deser.read_string(member)?);
-294
+                }
                 Some(8) => {
                     builder.tunnel_inside_ip_version = Some(crate::types::TunnelInsideIpVersion::from(deser.read_string(member)?.as_str()));
-297
+                }
                 Some(9) => {
                     builder.tunnel_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::TunnelOption::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TunnelOption::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-307
+                }
                 _ => {}
-309
+            }
             Ok(())
         })?;
         Ok(builder.build())
-313
+    }
-314
+}
 impl VpnConnectionOptions {
     /// 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 VpnConnectionOptions {
     /// Creates a new builder-style object to manufacture [`VpnConnectionOptions`](crate::types::VpnConnectionOptions).
     pub fn builder() -> crate::types::builders::VpnConnectionOptionsBuilder {
         crate::types::builders::VpnConnectionOptionsBuilder::default()
-330
+    }
-331
+}
-332
 /// A builder for [`VpnConnectionOptions`](crate::types::VpnConnectionOptions).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpnConnectionOptionsBuilder {
     pub(crate) enable_acceleration: ::std::option::Option<bool>,
     pub(crate) static_routes_only: ::std::option::Option<bool>,
     pub(crate) local_ipv4_network_cidr: ::std::option::Option<::std::string::String>,
     pub(crate) remote_ipv4_network_cidr: ::std::option::Option<::std::string::String>,
     pub(crate) local_ipv6_network_cidr: ::std::option::Option<::std::string::String>,
     pub(crate) remote_ipv6_network_cidr: ::std::option::Option<::std::string::String>,
     pub(crate) outside_ip_address_type: ::std::option::Option<::std::string::String>,
     pub(crate) transport_transit_gateway_attachment_id: ::std::option::Option<::std::string::String>,
     pub(crate) tunnel_inside_ip_version: ::std::option::Option<crate::types::TunnelInsideIpVersion>,
     pub(crate) tunnel_options: ::std::option::Option<::std::vec::Vec<crate::types::TunnelOption>>,
-347
+}
 impl VpnConnectionOptionsBuilder {
     /// <p>Indicates whether acceleration is enabled for the VPN connection.</p>
     pub fn enable_acceleration(mut self, input: bool) -> Self {
         self.enable_acceleration = ::std::option::Option::Some(input);
         self
-353
+    }
     /// <p>Indicates whether acceleration is enabled for the VPN connection.</p>
     pub fn set_enable_acceleration(mut self, input: ::std::option::Option<bool>) -> Self {

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

@@ -74,74 +225,225 @@

↥ Expand context

-74
+    }
     /// <p>The type of IP address assigned to the outside interface of the customer gateway device.</p>
     /// <p>Valid values: <code>PrivateIpv4</code> | <code>PublicIpv4</code> | <code>Ipv6</code></p>
     /// <p>Default: <code>PublicIpv4</code></p>
     pub fn outside_ip_address_type(&self) -> ::std::option::Option<&str> {
         self.outside_ip_address_type.as_deref()
-80
+    }
     /// <p>The transit gateway attachment ID to use for the VPN tunnel.</p>
     /// <p>Required if <code>OutsideIpAddressType</code> is set to <code>PrivateIpv4</code>.</p>
     pub fn transport_transit_gateway_attachment_id(&self) -> ::std::option::Option<&str> {
         self.transport_transit_gateway_attachment_id.as_deref()
-85
+    }
     /// <p>Indicate whether the VPN connection uses static routes only. If you are creating a VPN connection for a device that does not support BGP, you must specify <code>true</code>. Use <code>CreateVpnConnectionRoute</code> to create a static route.</p>
     /// <p>Default: <code>false</code></p>
     pub fn static_routes_only(&self) -> ::std::option::Option<bool> {
         self.static_routes_only
-90
+    }
-91
+}
 static VPNCONNECTIONOPTIONSSPECIFICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#VpnConnectionOptionsSpecification",

     "com.amazonaws.ec2",
     "VpnConnectionOptionsSpecification",
 );
 static VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_ENABLE_ACCELERATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptionsSpecification$EnableAcceleration",
         "com.amazonaws.ec2",
         "VpnConnectionOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "enable_acceleration",
     "EnableAcceleration",
 ,
 );
 static VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_TUNNEL_INSIDE_IP_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptionsSpecification$TunnelInsideIpVersion",
         "com.amazonaws.ec2",
         "VpnConnectionOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "tunnel_inside_ip_version",
     "TunnelInsideIpVersion",
 ,
 );
 static VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_TUNNEL_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptionsSpecification$TunnelOptions",
         "com.amazonaws.ec2",
         "VpnConnectionOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tunnel_options",
     "TunnelOptions",
 ,
 );
 static VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_LOCAL_IPV4_NETWORK_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptionsSpecification$LocalIpv4NetworkCidr",
         "com.amazonaws.ec2",
         "VpnConnectionOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "local_ipv4_network_cidr",
     "LocalIpv4NetworkCidr",
 ,
 );
 static VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_REMOTE_IPV4_NETWORK_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptionsSpecification$RemoteIpv4NetworkCidr",
         "com.amazonaws.ec2",
         "VpnConnectionOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "remote_ipv4_network_cidr",
     "RemoteIpv4NetworkCidr",
 ,
 );
 static VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_LOCAL_IPV6_NETWORK_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptionsSpecification$LocalIpv6NetworkCidr",
         "com.amazonaws.ec2",
         "VpnConnectionOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "local_ipv6_network_cidr",
     "LocalIpv6NetworkCidr",
 ,
 );
 static VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_REMOTE_IPV6_NETWORK_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptionsSpecification$RemoteIpv6NetworkCidr",
         "com.amazonaws.ec2",
         "VpnConnectionOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "remote_ipv6_network_cidr",
     "RemoteIpv6NetworkCidr",
 ,
 );
 static VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_OUTSIDE_IP_ADDRESS_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptionsSpecification$OutsideIpAddressType",
         "com.amazonaws.ec2",
         "VpnConnectionOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "outside_ip_address_type",
     "OutsideIpAddressType",
 ,
 );
 static VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_TRANSPORT_TRANSIT_GATEWAY_ATTACHMENT_ID: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2#VpnConnectionOptionsSpecification$TransportTransitGatewayAttachmentId",
             "com.amazonaws.ec2",
             "VpnConnectionOptionsSpecification",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "transport_transit_gateway_attachment_id",
         "TransportTransitGatewayAttachmentId",
 ,
     );
 static VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_STATIC_ROUTES_ONLY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnConnectionOptionsSpecification$StaticRoutesOnly",
         "com.amazonaws.ec2",
         "VpnConnectionOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "static_routes_only",
     "StaticRoutesOnly",
 ,
-197
+)
 .with_xml_name("staticRoutesOnly");
 static VPNCONNECTIONOPTIONSSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPNCONNECTIONOPTIONSSPECIFICATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_ENABLE_ACCELERATION,
         &VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_TUNNEL_INSIDE_IP_VERSION,
         &VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_TUNNEL_OPTIONS,

↧ Expand context

         &VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_LOCAL_IPV4_NETWORK_CIDR,
         &VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_REMOTE_IPV4_NETWORK_CIDR,
         &VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_LOCAL_IPV6_NETWORK_CIDR,
         &VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_REMOTE_IPV6_NETWORK_CIDR,
         &VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_OUTSIDE_IP_ADDRESS_TYPE,
         &VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_TRANSPORT_TRANSIT_GATEWAY_ATTACHMENT_ID,
         &VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_STATIC_ROUTES_ONLY,
     ],
 );
 impl VpnConnectionOptionsSpecification {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPNCONNECTIONOPTIONSSPECIFICATION_SCHEMA;
-218
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpnConnectionOptionsSpecification {
     #[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.enable_acceleration {

@@ -238,238 +358,366 @@

↥ Expand context

                     Ok(())
                 },
             )?;
-241
+        }
         if let Some(ref val) = self.local_ipv4_network_cidr {
             ser.write_string(&VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_LOCAL_IPV4_NETWORK_CIDR, val)?;
-244
+        }
         if let Some(ref val) = self.remote_ipv4_network_cidr {
             ser.write_string(&VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_REMOTE_IPV4_NETWORK_CIDR, val)?;
-247
+        }
         if let Some(ref val) = self.local_ipv6_network_cidr {
             ser.write_string(&VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_LOCAL_IPV6_NETWORK_CIDR, val)?;
-250
+        }
         if let Some(ref val) = self.remote_ipv6_network_cidr {
             ser.write_string(&VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_REMOTE_IPV6_NETWORK_CIDR, val)?;
-253
+        }
         if let Some(ref val) = self.outside_ip_address_type {
             ser.write_string(&VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_OUTSIDE_IP_ADDRESS_TYPE, val)?;
-256
+        }
         if let Some(ref val) = self.transport_transit_gateway_attachment_id {

             ser.write_string(&VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_TRANSPORT_TRANSIT_GATEWAY_ATTACHMENT_ID, val)?;
-259
+        }
         if let Some(ref val) = self.static_routes_only {
             ser.write_boolean(&VPNCONNECTIONOPTIONSSPECIFICATION_MEMBER_STATIC_ROUTES_ONLY, *val)?;
-262
+        }
         Ok(())
-264
+    }
-265
+}
 impl VpnConnectionOptionsSpecification {
     /// 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(&VPNCONNECTIONOPTIONSSPECIFICATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPNCONNECTIONOPTIONSSPECIFICATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.enable_acceleration = Some(deser.read_boolean(member)?);
-284
+                }
                 Some(1) => {
                     builder.tunnel_inside_ip_version = Some(crate::types::TunnelInsideIpVersion::from(deser.read_string(member)?.as_str()));
-287
+                }
                 Some(2) => {
                     builder.tunnel_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::VpnTunnelOptionsSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::VpnTunnelOptionsSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-297
+                }
                 Some(3) => {
                     builder.local_ipv4_network_cidr = Some(deser.read_string(member)?);
-300
+                }
                 Some(4) => {
                     builder.remote_ipv4_network_cidr = Some(deser.read_string(member)?);
-303
+                }
                 Some(5) => {
                     builder.local_ipv6_network_cidr = Some(deser.read_string(member)?);
-306
+                }
                 Some(6) => {
                     builder.remote_ipv6_network_cidr = Some(deser.read_string(member)?);
-309
+                }
                 Some(7) => {
                     builder.outside_ip_address_type = Some(deser.read_string(member)?);
-312
+                }
                 Some(8) => {
                     builder.transport_transit_gateway_attachment_id = Some(deser.read_string(member)?);
-315
+                }
                 Some(9) => {
                     builder.static_routes_only = Some(deser.read_boolean(member)?);
-318
+                }
                 _ => {}
-320
+            }
             Ok(())
         })?;
         Ok(builder.build())
-324
+    }
-325
+}
 impl VpnConnectionOptionsSpecification {
     /// 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 VpnConnectionOptionsSpecification {
     /// Creates a new builder-style object to manufacture [`VpnConnectionOptionsSpecification`](crate::types::VpnConnectionOptionsSpecification).
     pub fn builder() -> crate::types::builders::VpnConnectionOptionsSpecificationBuilder {
         crate::types::builders::VpnConnectionOptionsSpecificationBuilder::default()
-341
+    }
-342
+}
-343
 /// A builder for [`VpnConnectionOptionsSpecification`](crate::types::VpnConnectionOptionsSpecification).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpnConnectionOptionsSpecificationBuilder {
     pub(crate) enable_acceleration: ::std::option::Option<bool>,
     pub(crate) tunnel_inside_ip_version: ::std::option::Option<crate::types::TunnelInsideIpVersion>,
     pub(crate) tunnel_options: ::std::option::Option<::std::vec::Vec<crate::types::VpnTunnelOptionsSpecification>>,
     pub(crate) local_ipv4_network_cidr: ::std::option::Option<::std::string::String>,
     pub(crate) remote_ipv4_network_cidr: ::std::option::Option<::std::string::String>,
     pub(crate) local_ipv6_network_cidr: ::std::option::Option<::std::string::String>,
     pub(crate) remote_ipv6_network_cidr: ::std::option::Option<::std::string::String>,
     pub(crate) outside_ip_address_type: ::std::option::Option<::std::string::String>,
     pub(crate) transport_transit_gateway_attachment_id: ::std::option::Option<::std::string::String>,
     pub(crate) static_routes_only: ::std::option::Option<bool>,
-358
+}
 impl VpnConnectionOptionsSpecificationBuilder {
     /// <p>Indicate whether to enable acceleration for the VPN connection.</p>
     /// <p>Default: <code>false</code></p>
     pub fn enable_acceleration(mut self, input: bool) -> Self {
         self.enable_acceleration = ::std::option::Option::Some(input);
         self
-365
+    }
     /// <p>Indicate whether to enable acceleration for the VPN connection.</p>

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

@@ -31,31 +133,133 @@

↥ Expand context

         self.tags.as_deref().unwrap_or_default()
-32
+    }
     /// <p>The ID of the virtual private gateway.</p>
     pub fn vpn_gateway_id(&self) -> ::std::option::Option<&str> {
         self.vpn_gateway_id.as_deref()
-36
+    }
     /// <p>The current state of the virtual private gateway.</p>
     pub fn state(&self) -> ::std::option::Option<&crate::types::VpnState> {
         self.state.as_ref()
-40
+    }
     /// <p>The type of VPN connection the virtual private gateway supports.</p>
     pub fn r#type(&self) -> ::std::option::Option<&crate::types::GatewayType> {
         self.r#type.as_ref()
-44
+    }
     /// <p>The Availability Zone where the virtual private gateway was created, if applicable. This field may be empty or not returned.</p>
     pub fn availability_zone(&self) -> ::std::option::Option<&str> {
         self.availability_zone.as_deref()
-48
+    }
     /// <p>Any VPCs attached to the virtual private gateway.</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 `.vpc_attachments.is_none()`.
     pub fn vpc_attachments(&self) -> &[crate::types::VpcAttachment] {
         self.vpc_attachments.as_deref().unwrap_or_default()
-54
+    }
-55
+}
 static VPNGATEWAY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnGateway", "com.amazonaws.ec2", "VpnGateway");
 static VPNGATEWAY_MEMBER_AMAZON_SIDE_ASN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnGateway$AmazonSideAsn", "com.amazonaws.ec2", "VpnGateway"),
     ::aws_smithy_schema::ShapeType::Long,
     "amazon_side_asn",
     "AmazonSideAsn",
 ,
-63
+)
 .with_xml_name("amazonSideAsn");
 static VPNGATEWAY_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnGateway$Tags", "com.amazonaws.ec2", "VpnGateway"),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-70
+)
 .with_xml_name("tagSet");
 static VPNGATEWAY_MEMBER_VPN_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnGateway$VpnGatewayId", "com.amazonaws.ec2", "VpnGateway"),
     ::aws_smithy_schema::ShapeType::String,
     "vpn_gateway_id",
     "VpnGatewayId",
 ,
-77
+)
 .with_xml_name("vpnGatewayId");
 static VPNGATEWAY_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnGateway$State", "com.amazonaws.ec2", "VpnGateway"),
     ::aws_smithy_schema::ShapeType::String,
     "state",
     "State",
 ,
-84
+)
 .with_xml_name("state");
 static VPNGATEWAY_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnGateway$Type", "com.amazonaws.ec2", "VpnGateway"),
     ::aws_smithy_schema::ShapeType::String,
     "r##type",
     "Type",
 ,
-91
+)
 .with_xml_name("type");
 static VPNGATEWAY_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnGateway$AvailabilityZone", "com.amazonaws.ec2", "VpnGateway"),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone",
     "AvailabilityZone",
 ,
-98
+)
 .with_xml_name("availabilityZone");
 static VPNGATEWAY_MEMBER_VPC_ATTACHMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnGateway$VpcAttachments", "com.amazonaws.ec2", "VpnGateway"),
     ::aws_smithy_schema::ShapeType::List,
     "vpc_attachments",
     "VpcAttachments",
 ,
-105
+)
 .with_xml_name("attachments");
 static VPNGATEWAY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPNGATEWAY_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPNGATEWAY_MEMBER_AMAZON_SIDE_ASN,
         &VPNGATEWAY_MEMBER_TAGS,
         &VPNGATEWAY_MEMBER_VPN_GATEWAY_ID,

↧ Expand context

         &VPNGATEWAY_MEMBER_STATE,
         &VPNGATEWAY_MEMBER_TYPE,
         &VPNGATEWAY_MEMBER_AVAILABILITY_ZONE,
         &VPNGATEWAY_MEMBER_VPC_ATTACHMENTS,
     ],
 );
 impl VpnGateway {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPNGATEWAY_SCHEMA;
-123
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpnGateway {
     #[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.amazon_side_asn {
             ser.write_long(&VPNGATEWAY_MEMBER_AMAZON_SIDE_ASN, *val)?;
-132
+        }
         if let Some(ref val) = self.tags {

@@ -139,139 +260,265 @@

↥ Expand context

             })?;
-140
+        }
         if let Some(ref val) = self.vpn_gateway_id {
             ser.write_string(&VPNGATEWAY_MEMBER_VPN_GATEWAY_ID, val)?;
-143
+        }
         if let Some(ref val) = self.state {
             ser.write_string(&VPNGATEWAY_MEMBER_STATE, val.as_str())?;
-146
+        }
         if let Some(ref val) = self.r#type {
             ser.write_string(&VPNGATEWAY_MEMBER_TYPE, val.as_str())?;
-149
+        }
         if let Some(ref val) = self.availability_zone {
             ser.write_string(&VPNGATEWAY_MEMBER_AVAILABILITY_ZONE, val)?;
-152
+        }
         if let Some(ref val) = self.vpc_attachments {
             ser.write_list(
                 &VPNGATEWAY_MEMBER_VPC_ATTACHMENTS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::VpcAttachment::SCHEMA, item)?;

-159
+                    }
                     Ok(())
                 },
             )?;
-163
+        }
         Ok(())
-165
+    }
-166
+}
 impl VpnGateway {
     /// 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(&VPNGATEWAY_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPNGATEWAY_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.amazon_side_asn = Some(deser.read_long(member)?);
-185
+                }
                 Some(1) => {
                     builder.tags = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Tag::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-195
+                }
                 Some(2) => {
                     builder.vpn_gateway_id = Some(deser.read_string(member)?);
-198
+                }
                 Some(3) => {
                     builder.state = Some(crate::types::VpnState::from(deser.read_string(member)?.as_str()));
-201
+                }
                 Some(4) => {
                     builder.r#type = Some(crate::types::GatewayType::from(deser.read_string(member)?.as_str()));
-204
+                }
                 Some(5) => {
                     builder.availability_zone = Some(deser.read_string(member)?);
-207
+                }
                 Some(6) => {
                     builder.vpc_attachments = 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::VpcAttachment::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::VpcAttachment::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-217
+                }
                 _ => {}
-219
+            }
             Ok(())
         })?;
         Ok(builder.build())
-223
+    }
-224
+}
 impl VpnGateway {
     /// 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 VpnGateway {
     /// Creates a new builder-style object to manufacture [`VpnGateway`](crate::types::VpnGateway).
     pub fn builder() -> crate::types::builders::VpnGatewayBuilder {
         crate::types::builders::VpnGatewayBuilder::default()
-240
+    }
-241
+}
-242
 /// A builder for [`VpnGateway`](crate::types::VpnGateway).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpnGatewayBuilder {
     pub(crate) amazon_side_asn: ::std::option::Option<i64>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) vpn_gateway_id: ::std::option::Option<::std::string::String>,
     pub(crate) state: ::std::option::Option<crate::types::VpnState>,
     pub(crate) r#type: ::std::option::Option<crate::types::GatewayType>,
     pub(crate) availability_zone: ::std::option::Option<::std::string::String>,
     pub(crate) vpc_attachments: ::std::option::Option<::std::vec::Vec<crate::types::VpcAttachment>>,
-254
+}
 impl VpnGatewayBuilder {
     /// <p>The private Autonomous System Number (ASN) for the Amazon side of a BGP session.</p>
     pub fn amazon_side_asn(mut self, input: i64) -> Self {
         self.amazon_side_asn = ::std::option::Option::Some(input);
         self
-260
+    }
     /// <p>The private Autonomous System Number (ASN) for the Amazon side of a BGP session.</p>
     pub fn set_amazon_side_asn(mut self, input: ::std::option::Option<i64>) -> Self {
         self.amazon_side_asn = input;
         self
-265
+    }

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

@@ -7,7 +147,158 @@

↥ Expand context

     /// <p>The CIDR block associated with the local subnet of the customer data center.</p>
     pub destination_cidr_block: ::std::option::Option<::std::string::String>,
     /// <p>Indicates how the routes were provided.</p>
     pub source: ::std::option::Option<crate::types::VpnStaticRouteSource>,
     /// <p>The current state of the static route.</p>
     pub state: ::std::option::Option<crate::types::VpnState>,
-13
+}
 impl VpnStaticRoute {
     /// <p>The CIDR block associated with the local subnet of the customer data center.</p>
     pub fn destination_cidr_block(&self) -> ::std::option::Option<&str> {
         self.destination_cidr_block.as_deref()
-18
+    }
     /// <p>Indicates how the routes were provided.</p>
     pub fn source(&self) -> ::std::option::Option<&crate::types::VpnStaticRouteSource> {
         self.source.as_ref()
-22
+    }
     /// <p>The current state of the static route.</p>
     pub fn state(&self) -> ::std::option::Option<&crate::types::VpnState> {
         self.state.as_ref()
-26
+    }

-27
+}
 static VPNSTATICROUTE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnStaticRoute", "com.amazonaws.ec2", "VpnStaticRoute");
 static VPNSTATICROUTE_MEMBER_DESTINATION_CIDR_BLOCK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnStaticRoute$DestinationCidrBlock",
         "com.amazonaws.ec2",
         "VpnStaticRoute",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "destination_cidr_block",
     "DestinationCidrBlock",
 ,
-39
+)
 .with_xml_name("destinationCidrBlock");
 static VPNSTATICROUTE_MEMBER_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnStaticRoute$Source", "com.amazonaws.ec2", "VpnStaticRoute"),
     ::aws_smithy_schema::ShapeType::String,
     "source",
     "Source",
 ,
-46
+)
 .with_xml_name("source");
 static VPNSTATICROUTE_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnStaticRoute$State", "com.amazonaws.ec2", "VpnStaticRoute"),
     ::aws_smithy_schema::ShapeType::String,
     "state",
     "State",
 ,
-53
+)
 .with_xml_name("state");
 static VPNSTATICROUTE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPNSTATICROUTE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPNSTATICROUTE_MEMBER_DESTINATION_CIDR_BLOCK,
         &VPNSTATICROUTE_MEMBER_SOURCE,
         &VPNSTATICROUTE_MEMBER_STATE,
     ],
 );
 impl VpnStaticRoute {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPNSTATICROUTE_SCHEMA;
-67
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpnStaticRoute {
     #[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.destination_cidr_block {
             ser.write_string(&VPNSTATICROUTE_MEMBER_DESTINATION_CIDR_BLOCK, val)?;
-76
+        }
         if let Some(ref val) = self.source {
             ser.write_string(&VPNSTATICROUTE_MEMBER_SOURCE, val.as_str())?;
-79
+        }
         if let Some(ref val) = self.state {
             ser.write_string(&VPNSTATICROUTE_MEMBER_STATE, val.as_str())?;
-82
+        }
         Ok(())
-84
+    }
-85
+}
 impl VpnStaticRoute {
     /// 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(&VPNSTATICROUTE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPNSTATICROUTE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.destination_cidr_block = Some(deser.read_string(member)?);
-104
+                }
                 Some(1) => {
                     builder.source = Some(crate::types::VpnStaticRouteSource::from(deser.read_string(member)?.as_str()));
-107
+                }
                 Some(2) => {
                     builder.state = Some(crate::types::VpnState::from(deser.read_string(member)?.as_str()));
-110
+                }
                 _ => {}
-112
+            }
             Ok(())
         })?;
         Ok(builder.build())
-116
+    }
-117
+}
 impl VpnStaticRoute {
     /// 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 VpnStaticRoute {
     /// Creates a new builder-style object to manufacture [`VpnStaticRoute`](crate::types::VpnStaticRoute).
     pub fn builder() -> crate::types::builders::VpnStaticRouteBuilder {
         crate::types::builders::VpnStaticRouteBuilder::default()
-133
+    }
-134
+}
-135
 /// A builder for [`VpnStaticRoute`](crate::types::VpnStaticRoute).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpnStaticRouteBuilder {
     pub(crate) destination_cidr_block: ::std::option::Option<::std::string::String>,
     pub(crate) source: ::std::option::Option<crate::types::VpnStaticRouteSource>,
     pub(crate) state: ::std::option::Option<crate::types::VpnState>,
-143
+}
 impl VpnStaticRouteBuilder {
     /// <p>The CIDR block associated with the local subnet of the customer data center.</p>
     pub fn destination_cidr_block(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.destination_cidr_block = ::std::option::Option::Some(input.into());
         self
-149
+    }
     /// <p>The CIDR block associated with the local subnet of the customer data center.</p>
     pub fn set_destination_cidr_block(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.destination_cidr_block = input;
         self
-154
+    }
     /// <p>The CIDR block associated with the local subnet of the customer data center.</p>
     pub fn get_destination_cidr_block(&self) -> &::std::option::Option<::std::string::String> {
         &self.destination_cidr_block
-158
+    }

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

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Options for logging VPN tunnel activity.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct VpnTunnelLogOptions {
     /// <p>Options for sending VPN tunnel logs to CloudWatch.</p>
     pub cloud_watch_log_options: ::std::option::Option<crate::types::CloudWatchLogOptions>,
-9
+}
 impl VpnTunnelLogOptions {
     /// <p>Options for sending VPN tunnel logs to CloudWatch.</p>
     pub fn cloud_watch_log_options(&self) -> ::std::option::Option<&crate::types::CloudWatchLogOptions> {
         self.cloud_watch_log_options.as_ref()
-14
+    }

-15
+}
 static VPNTUNNELLOGOPTIONS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpnTunnelLogOptions", "com.amazonaws.ec2", "VpnTunnelLogOptions");
 static VPNTUNNELLOGOPTIONS_MEMBER_CLOUD_WATCH_LOG_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelLogOptions$CloudWatchLogOptions",
         "com.amazonaws.ec2",
         "VpnTunnelLogOptions",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "cloud_watch_log_options",
     "CloudWatchLogOptions",
 ,
-27
+)
 .with_xml_name("cloudWatchLogOptions");
 static VPNTUNNELLOGOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPNTUNNELLOGOPTIONS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&VPNTUNNELLOGOPTIONS_MEMBER_CLOUD_WATCH_LOG_OPTIONS],
 );
 impl VpnTunnelLogOptions {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPNTUNNELLOGOPTIONS_SCHEMA;
-37
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for VpnTunnelLogOptions {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.cloud_watch_log_options {
             ser.write_struct(&VPNTUNNELLOGOPTIONS_MEMBER_CLOUD_WATCH_LOG_OPTIONS, val)?;
-46
+        }
         Ok(())
-48
+    }
-49
+}
 impl VpnTunnelLogOptions {
     /// 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(&VPNTUNNELLOGOPTIONS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPNTUNNELLOGOPTIONS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cloud_watch_log_options = Some(crate::types::CloudWatchLogOptions::deserialize(deser)?);
-68
+                }
                 _ => {}
-70
+            }
             Ok(())
         })?;
         Ok(builder.build())
-74
+    }
-75
+}
 impl VpnTunnelLogOptions {
     /// 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 VpnTunnelLogOptions {
     /// Creates a new builder-style object to manufacture [`VpnTunnelLogOptions`](crate::types::VpnTunnelLogOptions).
     pub fn builder() -> crate::types::builders::VpnTunnelLogOptionsBuilder {
         crate::types::builders::VpnTunnelLogOptionsBuilder::default()
-91
+    }
-92
+}
-93
 /// A builder for [`VpnTunnelLogOptions`](crate::types::VpnTunnelLogOptions).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpnTunnelLogOptionsBuilder {
     pub(crate) cloud_watch_log_options: ::std::option::Option<crate::types::CloudWatchLogOptions>,
-99
+}
 impl VpnTunnelLogOptionsBuilder {
     /// <p>Options for sending VPN tunnel logs to CloudWatch.</p>
     pub fn cloud_watch_log_options(mut self, input: crate::types::CloudWatchLogOptions) -> Self {
         self.cloud_watch_log_options = ::std::option::Option::Some(input);
         self
-105
+    }
     /// <p>Options for sending VPN tunnel logs to CloudWatch.</p>
     pub fn set_cloud_watch_log_options(mut self, input: ::std::option::Option<crate::types::CloudWatchLogOptions>) -> Self {
         self.cloud_watch_log_options = input;
         self
-110
+    }
     /// <p>Options for sending VPN tunnel logs to CloudWatch.</p>
     pub fn get_cloud_watch_log_options(&self) -> &::std::option::Option<crate::types::CloudWatchLogOptions> {
         &self.cloud_watch_log_options
-114
+    }
     /// Consumes the builder and constructs a [`VpnTunnelLogOptions`](crate::types::VpnTunnelLogOptions).
     pub fn build(self) -> crate::types::VpnTunnelLogOptions {

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

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Options for logging VPN tunnel activity.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct VpnTunnelLogOptionsSpecification {
     /// <p>Options for sending VPN tunnel logs to CloudWatch.</p>
     pub cloud_watch_log_options: ::std::option::Option<crate::types::CloudWatchLogOptionsSpecification>,
-9
+}
 impl VpnTunnelLogOptionsSpecification {
     /// <p>Options for sending VPN tunnel logs to CloudWatch.</p>
     pub fn cloud_watch_log_options(&self) -> ::std::option::Option<&crate::types::CloudWatchLogOptionsSpecification> {
         self.cloud_watch_log_options.as_ref()
-14
+    }
-15
+}
 static VPNTUNNELLOGOPTIONSSPECIFICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#VpnTunnelLogOptionsSpecification",

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

↧ Expand context

 pub struct VpnTunnelLogOptionsSpecificationBuilder {
     pub(crate) cloud_watch_log_options: ::std::option::Option<crate::types::CloudWatchLogOptionsSpecification>,
-101
+}
 impl VpnTunnelLogOptionsSpecificationBuilder {
     /// <p>Options for sending VPN tunnel logs to CloudWatch.</p>
     pub fn cloud_watch_log_options(mut self, input: crate::types::CloudWatchLogOptionsSpecification) -> Self {
         self.cloud_watch_log_options = ::std::option::Option::Some(input);
         self
-107
+    }
     /// <p>Options for sending VPN tunnel logs to CloudWatch.</p>
     pub fn set_cloud_watch_log_options(mut self, input: ::std::option::Option<crate::types::CloudWatchLogOptionsSpecification>) -> Self {
         self.cloud_watch_log_options = input;
         self
-112
+    }
     /// <p>Options for sending VPN tunnel logs to CloudWatch.</p>
     pub fn get_cloud_watch_log_options(&self) -> &::std::option::Option<crate::types::CloudWatchLogOptionsSpecification> {
         &self.cloud_watch_log_options
-116
+    }
     /// Consumes the builder and constructs a [`VpnTunnelLogOptionsSpecification`](crate::types::VpnTunnelLogOptionsSpecification).
     pub fn build(self) -> crate::types::VpnTunnelLogOptionsSpecification {

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

@@ -236,236 +493,493 @@

↥ Expand context

         formatter.field("rekey_margin_time_seconds", &self.rekey_margin_time_seconds);
         formatter.field("rekey_fuzz_percentage", &self.rekey_fuzz_percentage);
         formatter.field("replay_window_size", &self.replay_window_size);
         formatter.field("dpd_timeout_seconds", &self.dpd_timeout_seconds);
         formatter.field("dpd_timeout_action", &self.dpd_timeout_action);
         formatter.field("phase1_encryption_algorithms", &self.phase1_encryption_algorithms);
         formatter.field("phase2_encryption_algorithms", &self.phase2_encryption_algorithms);
         formatter.field("phase1_integrity_algorithms", &self.phase1_integrity_algorithms);
         formatter.field("phase2_integrity_algorithms", &self.phase2_integrity_algorithms);
         formatter.field("phase1_dh_group_numbers", &self.phase1_dh_group_numbers);
         formatter.field("phase2_dh_group_numbers", &self.phase2_dh_group_numbers);
         formatter.field("ike_versions", &self.ike_versions);
         formatter.field("startup_action", &self.startup_action);
         formatter.field("log_options", &self.log_options);
         formatter.field("enable_tunnel_lifecycle_control", &self.enable_tunnel_lifecycle_control);
         formatter.finish()
-252
+    }
-253
+}
 static VPNTUNNELOPTIONSSPECIFICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2#VpnTunnelOptionsSpecification",

     "com.amazonaws.ec2",
     "VpnTunnelOptionsSpecification",
 );
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_TUNNEL_INSIDE_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$TunnelInsideCidr",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "tunnel_inside_cidr",
     "TunnelInsideCidr",
 ,
 );
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_TUNNEL_INSIDE_IPV6_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$TunnelInsideIpv6Cidr",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "tunnel_inside_ipv6_cidr",
     "TunnelInsideIpv6Cidr",
 ,
 );
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PRE_SHARED_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$PreSharedKey",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "pre_shared_key",
     "PreSharedKey",
 ,
 );
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE1_LIFETIME_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$Phase1LifetimeSeconds",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "phase1_lifetime_seconds",
     "Phase1LifetimeSeconds",
 ,
 );
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE2_LIFETIME_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$Phase2LifetimeSeconds",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "phase2_lifetime_seconds",
     "Phase2LifetimeSeconds",
 ,
 );
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_REKEY_MARGIN_TIME_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$RekeyMarginTimeSeconds",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "rekey_margin_time_seconds",
     "RekeyMarginTimeSeconds",
 ,
 );
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_REKEY_FUZZ_PERCENTAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$RekeyFuzzPercentage",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "rekey_fuzz_percentage",
     "RekeyFuzzPercentage",
 ,
 );
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_REPLAY_WINDOW_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$ReplayWindowSize",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "replay_window_size",
     "ReplayWindowSize",
 ,
 );
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_DPD_TIMEOUT_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$DPDTimeoutSeconds",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "dpd_timeout_seconds",
     "DPDTimeoutSeconds",
 ,
 );
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_DPD_TIMEOUT_ACTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$DPDTimeoutAction",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "dpd_timeout_action",
     "DPDTimeoutAction",
 ,
 );
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE1_ENCRYPTION_ALGORITHMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$Phase1EncryptionAlgorithms",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "phase1_encryption_algorithms",
     "Phase1EncryptionAlgorithms",
 ,
-368
+)
 .with_xml_name("Phase1EncryptionAlgorithm");
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE2_ENCRYPTION_ALGORITHMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$Phase2EncryptionAlgorithms",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "phase2_encryption_algorithms",
     "Phase2EncryptionAlgorithms",
 ,
-379
+)
 .with_xml_name("Phase2EncryptionAlgorithm");
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE1_INTEGRITY_ALGORITHMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$Phase1IntegrityAlgorithms",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "phase1_integrity_algorithms",
     "Phase1IntegrityAlgorithms",
 ,
-390
+)
 .with_xml_name("Phase1IntegrityAlgorithm");
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE2_INTEGRITY_ALGORITHMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$Phase2IntegrityAlgorithms",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "phase2_integrity_algorithms",
     "Phase2IntegrityAlgorithms",
 ,
-401
+)
 .with_xml_name("Phase2IntegrityAlgorithm");
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE1_DH_GROUP_NUMBERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$Phase1DHGroupNumbers",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "phase1_dh_group_numbers",
     "Phase1DHGroupNumbers",
 ,
-412
+)
 .with_xml_name("Phase1DHGroupNumber");
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE2_DH_GROUP_NUMBERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$Phase2DHGroupNumbers",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "phase2_dh_group_numbers",
     "Phase2DHGroupNumbers",
 ,
-423
+)
 .with_xml_name("Phase2DHGroupNumber");
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_IKE_VERSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$IKEVersions",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "ike_versions",
     "IKEVersions",
 ,
-434
+)
 .with_xml_name("IKEVersion");
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_STARTUP_ACTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$StartupAction",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "startup_action",
     "StartupAction",
 ,
 );
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_LOG_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$LogOptions",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "log_options",
     "LogOptions",
 ,
 );
 static VPNTUNNELOPTIONSSPECIFICATION_MEMBER_ENABLE_TUNNEL_LIFECYCLE_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2#VpnTunnelOptionsSpecification$EnableTunnelLifecycleControl",
         "com.amazonaws.ec2",
         "VpnTunnelOptionsSpecification",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "enable_tunnel_lifecycle_control",
     "EnableTunnelLifecycleControl",
 ,
 );
 static VPNTUNNELOPTIONSSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VPNTUNNELOPTIONSSPECIFICATION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_TUNNEL_INSIDE_CIDR,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_TUNNEL_INSIDE_IPV6_CIDR,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PRE_SHARED_KEY,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE1_LIFETIME_SECONDS,

↧ Expand context

         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE2_LIFETIME_SECONDS,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_REKEY_MARGIN_TIME_SECONDS,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_REKEY_FUZZ_PERCENTAGE,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_REPLAY_WINDOW_SIZE,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_DPD_TIMEOUT_SECONDS,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_DPD_TIMEOUT_ACTION,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE1_ENCRYPTION_ALGORITHMS,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE2_ENCRYPTION_ALGORITHMS,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE1_INTEGRITY_ALGORITHMS,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE2_INTEGRITY_ALGORITHMS,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE1_DH_GROUP_NUMBERS,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_PHASE2_DH_GROUP_NUMBERS,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_IKE_VERSIONS,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_STARTUP_ACTION,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_LOG_OPTIONS,
         &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_ENABLE_TUNNEL_LIFECYCLE_CONTROL,
     ],
 );
 impl VpnTunnelOptionsSpecification {
     /// The schema for this shape.

@@ -593,593 +803,793 @@

↥ Expand context

-593
+                    }
                     Ok(())
                 },
             )?;
-597
+        }
         if let Some(ref val) = self.ike_versions {
             ser.write_list(
                 &VPNTUNNELOPTIONSSPECIFICATION_MEMBER_IKE_VERSIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::IkeVersionsRequestListValue::SCHEMA, item)?;
-604
+                    }
                     Ok(())
                 },
             )?;
-608
+        }
         if let Some(ref val) = self.startup_action {
             ser.write_string(&VPNTUNNELOPTIONSSPECIFICATION_MEMBER_STARTUP_ACTION, val)?;
-611
+        }
         if let Some(ref val) = self.log_options {

             ser.write_struct(&VPNTUNNELOPTIONSSPECIFICATION_MEMBER_LOG_OPTIONS, val)?;
-614
+        }
         if let Some(ref val) = self.enable_tunnel_lifecycle_control {
             ser.write_boolean(&VPNTUNNELOPTIONSSPECIFICATION_MEMBER_ENABLE_TUNNEL_LIFECYCLE_CONTROL, *val)?;
-617
+        }
         Ok(())
-619
+    }
-620
+}
 impl VpnTunnelOptionsSpecification {
     /// 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(&VPNTUNNELOPTIONSSPECIFICATION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VPNTUNNELOPTIONSSPECIFICATION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.tunnel_inside_cidr = Some(deser.read_string(member)?);
-639
+                }
                 Some(1) => {
                     builder.tunnel_inside_ipv6_cidr = Some(deser.read_string(member)?);
-642
+                }
                 Some(2) => {
                     builder.pre_shared_key = Some(deser.read_string(member)?);
-645
+                }
                 Some(3) => {
                     builder.phase1_lifetime_seconds = Some(deser.read_integer(member)?);
-648
+                }
                 Some(4) => {
                     builder.phase2_lifetime_seconds = Some(deser.read_integer(member)?);
-651
+                }
                 Some(5) => {
                     builder.rekey_margin_time_seconds = Some(deser.read_integer(member)?);
-654
+                }
                 Some(6) => {
                     builder.rekey_fuzz_percentage = Some(deser.read_integer(member)?);
-657
+                }
                 Some(7) => {
                     builder.replay_window_size = Some(deser.read_integer(member)?);
-660
+                }
                 Some(8) => {
                     builder.dpd_timeout_seconds = Some(deser.read_integer(member)?);
-663
+                }
                 Some(9) => {
                     builder.dpd_timeout_action = Some(deser.read_string(member)?);
-666
+                }
                 Some(10) => {
                     builder.phase1_encryption_algorithms = 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::Phase1EncryptionAlgorithmsRequestListValue::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Phase1EncryptionAlgorithmsRequestListValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-676
+                }
                 Some(11) => {
                     builder.phase2_encryption_algorithms = 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::Phase2EncryptionAlgorithmsRequestListValue::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Phase2EncryptionAlgorithmsRequestListValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-686
+                }
                 Some(12) => {
                     builder.phase1_integrity_algorithms = 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::Phase1IntegrityAlgorithmsRequestListValue::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Phase1IntegrityAlgorithmsRequestListValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-696
+                }
                 Some(13) => {
                     builder.phase2_integrity_algorithms = 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::Phase2IntegrityAlgorithmsRequestListValue::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Phase2IntegrityAlgorithmsRequestListValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-706
+                }
                 Some(14) => {
                     builder.phase1_dh_group_numbers = 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::Phase1DhGroupNumbersRequestListValue::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Phase1DhGroupNumbersRequestListValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-716
+                }
                 Some(15) => {
                     builder.phase2_dh_group_numbers = 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::Phase2DhGroupNumbersRequestListValue::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Phase2DhGroupNumbersRequestListValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-726
+                }
                 Some(16) => {
                     builder.ike_versions = 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::IkeVersionsRequestListValue::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::IkeVersionsRequestListValue::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-736
+                }
                 Some(17) => {
                     builder.startup_action = Some(deser.read_string(member)?);
-739
+                }
                 Some(18) => {
                     builder.log_options = Some(crate::types::VpnTunnelLogOptionsSpecification::deserialize(deser)?);
-742
+                }
                 Some(19) => {
                     builder.enable_tunnel_lifecycle_control = Some(deser.read_boolean(member)?);
-745
+                }
                 _ => {}
-747
+            }
             Ok(())
         })?;
         Ok(builder.build())
-751
+    }
-752
+}
 impl VpnTunnelOptionsSpecification {
     /// 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 VpnTunnelOptionsSpecification {
     /// Creates a new builder-style object to manufacture [`VpnTunnelOptionsSpecification`](crate::types::VpnTunnelOptionsSpecification).
     pub fn builder() -> crate::types::builders::VpnTunnelOptionsSpecificationBuilder {
         crate::types::builders::VpnTunnelOptionsSpecificationBuilder::default()
-768
+    }
-769
+}
-770
 /// A builder for [`VpnTunnelOptionsSpecification`](crate::types::VpnTunnelOptionsSpecification).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct VpnTunnelOptionsSpecificationBuilder {
     pub(crate) tunnel_inside_cidr: ::std::option::Option<::std::string::String>,
     pub(crate) tunnel_inside_ipv6_cidr: ::std::option::Option<::std::string::String>,
     pub(crate) pre_shared_key: ::std::option::Option<::std::string::String>,
     pub(crate) phase1_lifetime_seconds: ::std::option::Option<i32>,
     pub(crate) phase2_lifetime_seconds: ::std::option::Option<i32>,
     pub(crate) rekey_margin_time_seconds: ::std::option::Option<i32>,
     pub(crate) rekey_fuzz_percentage: ::std::option::Option<i32>,
     pub(crate) replay_window_size: ::std::option::Option<i32>,
     pub(crate) dpd_timeout_seconds: ::std::option::Option<i32>,
     pub(crate) dpd_timeout_action: ::std::option::Option<::std::string::String>,
     pub(crate) phase1_encryption_algorithms: ::std::option::Option<::std::vec::Vec<crate::types::Phase1EncryptionAlgorithmsRequestListValue>>,
     pub(crate) phase2_encryption_algorithms: ::std::option::Option<::std::vec::Vec<crate::types::Phase2EncryptionAlgorithmsRequestListValue>>,
     pub(crate) phase1_integrity_algorithms: ::std::option::Option<::std::vec::Vec<crate::types::Phase1IntegrityAlgorithmsRequestListValue>>,
     pub(crate) phase2_integrity_algorithms: ::std::option::Option<::std::vec::Vec<crate::types::Phase2IntegrityAlgorithmsRequestListValue>>,
     pub(crate) phase1_dh_group_numbers: ::std::option::Option<::std::vec::Vec<crate::types::Phase1DhGroupNumbersRequestListValue>>,
     pub(crate) phase2_dh_group_numbers: ::std::option::Option<::std::vec::Vec<crate::types::Phase2DhGroupNumbersRequestListValue>>,
     pub(crate) ike_versions: ::std::option::Option<::std::vec::Vec<crate::types::IkeVersionsRequestListValue>>,
     pub(crate) startup_action: ::std::option::Option<::std::string::String>,
     pub(crate) log_options: ::std::option::Option<crate::types::VpnTunnelLogOptionsSpecification>,

AWS SDK

Files changed: