AWS SDK

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_volume/_create_volume_input.rs

@@ -231,231 +443,443 @@

     /// </note></li>
     /// <li>
     /// <p>You want to create a volume that is initialized at the default rate.</p></li>
     /// </ul>
     /// <p>For more information, see <a href="https://docs.aws.amazon.com/ebs/latest/userguide/initalize-volume.html"> Initialize Amazon EBS volumes</a> in the <i>Amazon EC2 User Guide</i>.</p>
     /// <p>Valid range: 100 - 300 MiB/s</p>
     pub fn volume_initialization_rate(&self) -> ::std::option::Option<i32> {
         self.volume_initialization_rate
-239
+    }
     /// <p>Reserved for internal use.</p>
     pub fn operator(&self) -> ::std::option::Option<&crate::types::OperatorRequest> {
         self.operator.as_ref()
-243
+    }
     /// <p>Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is <code>DryRunOperation</code>. Otherwise, it is <code>UnauthorizedOperation</code>.</p>
     pub fn dry_run(&self) -> ::std::option::Option<bool> {
         self.dry_run
-247
+    }
-248
+}
 static CREATEVOLUMEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateVolumeInput",

     "com.amazonaws.ec2.synthetic",
     "CreateVolumeInput",
 );
 static CREATEVOLUMEINPUT_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$AvailabilityZone",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone",
     "AvailabilityZone",
 ,
 );
 static CREATEVOLUMEINPUT_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$AvailabilityZoneId",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone_id",
     "AvailabilityZoneId",
 ,
 );
 static CREATEVOLUMEINPUT_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$Encrypted",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "encrypted",
     "Encrypted",
 ,
-283
+)
 .with_xml_name("encrypted");
 static CREATEVOLUMEINPUT_MEMBER_IOPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$Iops",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "iops",
     "Iops",
 ,
 );
 static CREATEVOLUMEINPUT_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$KmsKeyId",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "kms_key_id",
     "KmsKeyId",
 ,
 );
 static CREATEVOLUMEINPUT_MEMBER_OUTPOST_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$OutpostArn",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "outpost_arn",
     "OutpostArn",
 ,
 );
 static CREATEVOLUMEINPUT_MEMBER_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$Size",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "size",
     "Size",
 ,
 );
 static CREATEVOLUMEINPUT_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$SnapshotId",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "snapshot_id",
     "SnapshotId",
 ,
 );
 static CREATEVOLUMEINPUT_MEMBER_VOLUME_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$VolumeType",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "volume_type",
     "VolumeType",
 ,
 );
 static CREATEVOLUMEINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$TagSpecifications",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_specifications",
     "TagSpecifications",
 ,
-354
+)
 .with_xml_name("TagSpecification");
 static CREATEVOLUMEINPUT_MEMBER_MULTI_ATTACH_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$MultiAttachEnabled",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "multi_attach_enabled",
     "MultiAttachEnabled",
 ,
 );
 static CREATEVOLUMEINPUT_MEMBER_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$Throughput",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "throughput",
     "Throughput",
 ,
 );
 static CREATEVOLUMEINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$ClientToken",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
 );
 static CREATEVOLUMEINPUT_MEMBER_VOLUME_INITIALIZATION_RATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$VolumeInitializationRate",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "volume_initialization_rate",
     "VolumeInitializationRate",
 ,
 );
 static CREATEVOLUMEINPUT_MEMBER_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$Operator",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "operator",
     "Operator",
 ,
 );
 static CREATEVOLUMEINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
-415
+)
 .with_xml_name("dryRun");
 static CREATEVOLUMEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEVOLUMEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEVOLUMEINPUT_MEMBER_AVAILABILITY_ZONE,
         &CREATEVOLUMEINPUT_MEMBER_AVAILABILITY_ZONE_ID,
         &CREATEVOLUMEINPUT_MEMBER_ENCRYPTED,

↧ Expand context

         &CREATEVOLUMEINPUT_MEMBER_IOPS,
         &CREATEVOLUMEINPUT_MEMBER_KMS_KEY_ID,
         &CREATEVOLUMEINPUT_MEMBER_OUTPOST_ARN,
         &CREATEVOLUMEINPUT_MEMBER_SIZE,
         &CREATEVOLUMEINPUT_MEMBER_SNAPSHOT_ID,
         &CREATEVOLUMEINPUT_MEMBER_VOLUME_TYPE,
         &CREATEVOLUMEINPUT_MEMBER_TAG_SPECIFICATIONS,
         &CREATEVOLUMEINPUT_MEMBER_MULTI_ATTACH_ENABLED,
         &CREATEVOLUMEINPUT_MEMBER_THROUGHPUT,
         &CREATEVOLUMEINPUT_MEMBER_CLIENT_TOKEN,
         &CREATEVOLUMEINPUT_MEMBER_VOLUME_INITIALIZATION_RATE,
         &CREATEVOLUMEINPUT_MEMBER_OPERATOR,
         &CREATEVOLUMEINPUT_MEMBER_DRY_RUN,
     ],
 );
 impl CreateVolumeInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVOLUMEINPUT_SCHEMA;
-442
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateVolumeInput {

@@ -480,480 +620,628 @@

↥ Expand context

                     for item in val {
                         ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
-482
+                    }
                     Ok(())
                 },
             )?;
-486
+        }
         if let Some(ref val) = self.multi_attach_enabled {
             ser.write_boolean(&CREATEVOLUMEINPUT_MEMBER_MULTI_ATTACH_ENABLED, *val)?;
-489
+        }
         if let Some(ref val) = self.throughput {
             ser.write_integer(&CREATEVOLUMEINPUT_MEMBER_THROUGHPUT, *val)?;
-492
+        }
         if let Some(ref val) = self.client_token {
             ser.write_string(&CREATEVOLUMEINPUT_MEMBER_CLIENT_TOKEN, val)?;
-495
+        }
         if let Some(ref val) = self.volume_initialization_rate {
             ser.write_integer(&CREATEVOLUMEINPUT_MEMBER_VOLUME_INITIALIZATION_RATE, *val)?;
-498
+        }
         if let Some(ref val) = self.operator {

             ser.write_struct(&CREATEVOLUMEINPUT_MEMBER_OPERATOR, val)?;
-501
+        }
         if let Some(ref val) = self.dry_run {
             ser.write_boolean(&CREATEVOLUMEINPUT_MEMBER_DRY_RUN, *val)?;
-504
+        }
         Ok(())
-506
+    }
-507
+}
 impl CreateVolumeInput {
     /// 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(&CREATEVOLUMEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEVOLUMEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.availability_zone = Some(deser.read_string(member)?);
-526
+                }
                 Some(1) => {
                     builder.availability_zone_id = Some(deser.read_string(member)?);
-529
+                }
                 Some(2) => {
                     builder.encrypted = Some(deser.read_boolean(member)?);
-532
+                }
                 Some(3) => {
                     builder.iops = Some(deser.read_integer(member)?);
-535
+                }
                 Some(4) => {
                     builder.kms_key_id = Some(deser.read_string(member)?);
-538
+                }
                 Some(5) => {
                     builder.outpost_arn = Some(deser.read_string(member)?);
-541
+                }
                 Some(6) => {
                     builder.size = Some(deser.read_integer(member)?);
-544
+                }
                 Some(7) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-547
+                }
                 Some(8) => {
                     builder.volume_type = Some(crate::types::VolumeType::from(deser.read_string(member)?.as_str()));
-550
+                }
                 Some(9) => {
                     builder.tag_specifications = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-560
+                }
                 Some(10) => {
                     builder.multi_attach_enabled = Some(deser.read_boolean(member)?);
-563
+                }
                 Some(11) => {
                     builder.throughput = Some(deser.read_integer(member)?);
-566
+                }
                 Some(12) => {
                     builder.client_token = Some(deser.read_string(member)?);
-569
+                }
                 Some(13) => {
                     builder.volume_initialization_rate = Some(deser.read_integer(member)?);
-572
+                }
                 Some(14) => {
                     builder.operator = Some(crate::types::OperatorRequest::deserialize(deser)?);
-575
+                }
                 Some(15) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-578
+                }
                 _ => {}
-580
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-586
+    }
-587
+}
 impl CreateVolumeInput {
     /// 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 CreateVolumeInput {
     /// Creates a new builder-style object to manufacture [`CreateVolumeInput`](crate::operation::create_volume::CreateVolumeInput).
     pub fn builder() -> crate::operation::create_volume::builders::CreateVolumeInputBuilder {
         crate::operation::create_volume::builders::CreateVolumeInputBuilder::default()
-603
+    }
-604
+}
-605
 /// A builder for [`CreateVolumeInput`](crate::operation::create_volume::CreateVolumeInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CreateVolumeInputBuilder {
     pub(crate) availability_zone: ::std::option::Option<::std::string::String>,
     pub(crate) availability_zone_id: ::std::option::Option<::std::string::String>,
     pub(crate) encrypted: ::std::option::Option<bool>,
     pub(crate) iops: ::std::option::Option<i32>,
     pub(crate) kms_key_id: ::std::option::Option<::std::string::String>,
     pub(crate) outpost_arn: ::std::option::Option<::std::string::String>,
     pub(crate) size: ::std::option::Option<i32>,
     pub(crate) snapshot_id: ::std::option::Option<::std::string::String>,
     pub(crate) volume_type: ::std::option::Option<crate::types::VolumeType>,
     pub(crate) tag_specifications: ::std::option::Option<::std::vec::Vec<crate::types::TagSpecification>>,
     pub(crate) multi_attach_enabled: ::std::option::Option<bool>,
     pub(crate) throughput: ::std::option::Option<i32>,
     pub(crate) client_token: ::std::option::Option<::std::string::String>,
     pub(crate) volume_initialization_rate: ::std::option::Option<i32>,
     pub(crate) operator: ::std::option::Option<crate::types::OperatorRequest>,
     pub(crate) dry_run: ::std::option::Option<bool>,
-626
+}
 impl CreateVolumeInputBuilder {
     /// <p>The ID of the Availability Zone in which to create the volume. For example, <code>us-east-1a</code>.</p>

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_volume/_create_volume_output.rs

@@ -135,135 +431,439 @@

↥ Expand context

     /// <note>
     /// <p>This parameter is not returned by CreateVolume.</p>
     /// </note>
     /// <p>Information about the volume attachments.</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 `.attachments.is_none()`.
     pub fn attachments(&self) -> &[crate::types::VolumeAttachment] {
         self.attachments.as_deref().unwrap_or_default()
-143
+    }
     /// <p>Indicates whether the volume is encrypted.</p>
     pub fn encrypted(&self) -> ::std::option::Option<bool> {
         self.encrypted
-147
+    }
     /// <p>The Amazon Resource Name (ARN) of the KMS key that was used to protect the volume encryption key for the volume.</p>
     pub fn kms_key_id(&self) -> ::std::option::Option<&str> {
         self.kms_key_id.as_deref()
-151
+    }
-152
+}
 static CREATEVOLUMEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateVolumeOutput",

     "com.amazonaws.ec2.synthetic",
     "CreateVolumeOutput",
 );
 static CREATEVOLUMEOUTPUT_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$AvailabilityZoneId",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone_id",
     "AvailabilityZoneId",
 ,
-167
+)
 .with_xml_name("availabilityZoneId");
 static CREATEVOLUMEOUTPUT_MEMBER_OUTPOST_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$OutpostArn",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "outpost_arn",
     "OutpostArn",
 ,
-178
+)
 .with_xml_name("outpostArn");
 static CREATEVOLUMEOUTPUT_MEMBER_IOPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$Iops",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "iops",
     "Iops",
 ,
-189
+)
 .with_xml_name("iops");
 static CREATEVOLUMEOUTPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$Tags",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-200
+)
 .with_xml_name("tagSet");
 static CREATEVOLUMEOUTPUT_MEMBER_VOLUME_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$VolumeType",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "volume_type",
     "VolumeType",
 ,
-211
+)
 .with_xml_name("volumeType");
 static CREATEVOLUMEOUTPUT_MEMBER_FAST_RESTORED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$FastRestored",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "fast_restored",
     "FastRestored",
 ,
-222
+)
 .with_xml_name("fastRestored");
 static CREATEVOLUMEOUTPUT_MEMBER_MULTI_ATTACH_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$MultiAttachEnabled",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "multi_attach_enabled",
     "MultiAttachEnabled",
 ,
-233
+)
 .with_xml_name("multiAttachEnabled");
 static CREATEVOLUMEOUTPUT_MEMBER_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$Throughput",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "throughput",
     "Throughput",
 ,
-244
+)
 .with_xml_name("throughput");
 static CREATEVOLUMEOUTPUT_MEMBER_SSE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$SseType",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sse_type",
     "SseType",
 ,
-255
+)
 .with_xml_name("sseType");
 static CREATEVOLUMEOUTPUT_MEMBER_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$Operator",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "operator",
     "Operator",
 ,
-266
+)
 .with_xml_name("operator");
 static CREATEVOLUMEOUTPUT_MEMBER_VOLUME_INITIALIZATION_RATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$VolumeInitializationRate",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "volume_initialization_rate",
     "VolumeInitializationRate",
 ,
-277
+)
 .with_xml_name("volumeInitializationRate");
 static CREATEVOLUMEOUTPUT_MEMBER_VOLUME_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$VolumeId",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "volume_id",
     "VolumeId",
 ,
-288
+)
 .with_xml_name("volumeId");
 static CREATEVOLUMEOUTPUT_MEMBER_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$Size",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "size",
     "Size",
 ,
-299
+)
 .with_xml_name("size");
 static CREATEVOLUMEOUTPUT_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$SnapshotId",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "snapshot_id",
     "SnapshotId",
 ,
-310
+)
 .with_xml_name("snapshotId");
 static CREATEVOLUMEOUTPUT_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$AvailabilityZone",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone",
     "AvailabilityZone",
 ,
-321
+)
 .with_xml_name("availabilityZone");
 static CREATEVOLUMEOUTPUT_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$State",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "state",
     "State",
 ,
-332
+)
 .with_xml_name("status");
 static CREATEVOLUMEOUTPUT_MEMBER_CREATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$CreateTime",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "create_time",
     "CreateTime",
 ,
-343
+)
 .with_xml_name("createTime");
 static CREATEVOLUMEOUTPUT_MEMBER_ATTACHMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$Attachments",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "attachments",
     "Attachments",
 ,
-354
+)
 .with_xml_name("attachmentSet");
 static CREATEVOLUMEOUTPUT_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$Encrypted",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "encrypted",
     "Encrypted",
 ,
-365
+)
 .with_xml_name("encrypted");
 static CREATEVOLUMEOUTPUT_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVolumeOutput$KmsKeyId",
         "com.amazonaws.ec2.synthetic",
         "CreateVolumeOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "kms_key_id",
     "KmsKeyId",
 ,
-376
+)
 .with_xml_name("kmsKeyId");
 static CREATEVOLUMEOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static CREATEVOLUMEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEVOLUMEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEVOLUMEOUTPUT_MEMBER_AVAILABILITY_ZONE_ID,
         &CREATEVOLUMEOUTPUT_MEMBER_OUTPOST_ARN,
         &CREATEVOLUMEOUTPUT_MEMBER_IOPS,
         &CREATEVOLUMEOUTPUT_MEMBER_TAGS,
         &CREATEVOLUMEOUTPUT_MEMBER_VOLUME_TYPE,
         &CREATEVOLUMEOUTPUT_MEMBER_FAST_RESTORED,
         &CREATEVOLUMEOUTPUT_MEMBER_MULTI_ATTACH_ENABLED,
         &CREATEVOLUMEOUTPUT_MEMBER_THROUGHPUT,
         &CREATEVOLUMEOUTPUT_MEMBER_SSE_TYPE,
         &CREATEVOLUMEOUTPUT_MEMBER_OPERATOR,
         &CREATEVOLUMEOUTPUT_MEMBER_VOLUME_INITIALIZATION_RATE,
         &CREATEVOLUMEOUTPUT_MEMBER_VOLUME_ID,
         &CREATEVOLUMEOUTPUT_MEMBER_SIZE,
         &CREATEVOLUMEOUTPUT_MEMBER_SNAPSHOT_ID,
         &CREATEVOLUMEOUTPUT_MEMBER_AVAILABILITY_ZONE,
         &CREATEVOLUMEOUTPUT_MEMBER_STATE,
         &CREATEVOLUMEOUTPUT_MEMBER_CREATE_TIME,
         &CREATEVOLUMEOUTPUT_MEMBER_ATTACHMENTS,
         &CREATEVOLUMEOUTPUT_MEMBER_ENCRYPTED,
         &CREATEVOLUMEOUTPUT_MEMBER_KMS_KEY_ID,
         &CREATEVOLUMEOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl CreateVolumeOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVOLUMEOUTPUT_SCHEMA;
-415
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateVolumeOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,

↧ Expand context

         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.availability_zone_id {
             ser.write_string(&CREATEVOLUMEOUTPUT_MEMBER_AVAILABILITY_ZONE_ID, val)?;
-424
+        }
         if let Some(ref val) = self.outpost_arn {
             ser.write_string(&CREATEVOLUMEOUTPUT_MEMBER_OUTPOST_ARN, val)?;
-427
+        }
         if let Some(ref val) = self.iops {
             ser.write_integer(&CREATEVOLUMEOUTPUT_MEMBER_IOPS, *val)?;
-430
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &CREATEVOLUMEOUTPUT_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-437
+                    }
                     Ok(())
                 },

@@ -465,473 +610,720 @@

↥ Expand context

             ser.write_string(&CREATEVOLUMEOUTPUT_MEMBER_AVAILABILITY_ZONE, val)?;
-474
+        }
         if let Some(ref val) = self.state {
             ser.write_string(&CREATEVOLUMEOUTPUT_MEMBER_STATE, val.as_str())?;
-477
+        }
         if let Some(ref val) = self.create_time {
             ser.write_timestamp(&CREATEVOLUMEOUTPUT_MEMBER_CREATE_TIME, val)?;
-480
+        }
         if let Some(ref val) = self.attachments {
             ser.write_list(
                 &CREATEVOLUMEOUTPUT_MEMBER_ATTACHMENTS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::VolumeAttachment::SCHEMA, item)?;
-487
+                    }
                     Ok(())
                 },
             )?;
-491
+        }
         if let Some(ref val) = self.encrypted {

             ser.write_boolean(&CREATEVOLUMEOUTPUT_MEMBER_ENCRYPTED, *val)?;
-494
+        }
         if let Some(ref val) = self.kms_key_id {
             ser.write_string(&CREATEVOLUMEOUTPUT_MEMBER_KMS_KEY_ID, val)?;
-497
+        }
         Ok(())
-499
+    }
-500
+}
 impl CreateVolumeOutput {
     /// 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(&CREATEVOLUMEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEVOLUMEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.availability_zone_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.outpost_arn = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder.iops = Some(deser.read_integer(member)?);
-+
+                }
                 Some(3) => {
                     builder.tags = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(4) => {
                     builder.volume_type = Some(crate::types::VolumeType::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(5) => {
                     builder.fast_restored = Some(deser.read_boolean(member)?);
-+
+                }
                 Some(6) => {
                     builder.multi_attach_enabled = Some(deser.read_boolean(member)?);
-+
+                }
                 Some(7) => {
                     builder.throughput = Some(deser.read_integer(member)?);
-+
+                }
                 Some(8) => {
                     builder.sse_type = Some(crate::types::SseType::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(9) => {
                     builder.operator = Some(crate::types::OperatorResponse::deserialize(deser)?);
-+
+                }
                 Some(10) => {
                     builder.volume_initialization_rate = Some(deser.read_integer(member)?);
-+
+                }
                 Some(11) => {
                     builder.volume_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(12) => {
                     builder.size = Some(deser.read_integer(member)?);
-+
+                }
                 Some(13) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(14) => {
                     builder.availability_zone = Some(deser.read_string(member)?);
-+
+                }
                 Some(15) => {
                     builder.state = Some(crate::types::VolumeState::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(16) => {
                     builder.create_time = Some(deser.read_timestamp(member)?);
-+
+                }
                 Some(17) => {
                     builder.attachments = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::VolumeAttachment::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(18) => {
                     builder.encrypted = Some(deser.read_boolean(member)?);
-+
+                }
                 Some(19) => {
                     builder.kms_key_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(20) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateVolumeOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATEVOLUMEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.availability_zone_id = Some(deser.read_string(member)?);
-627
+                }
                 Some(1) => {
                     builder.outpost_arn = Some(deser.read_string(member)?);
-630
+                }
                 Some(2) => {
                     builder.iops = Some(deser.read_integer(member)?);
-633
+                }
                 Some(3) => {
                     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
                     });
-643
+                }
                 Some(4) => {
                     builder.volume_type = Some(crate::types::VolumeType::from(deser.read_string(member)?.as_str()));
-646
+                }
                 Some(5) => {
                     builder.fast_restored = Some(deser.read_boolean(member)?);
-649
+                }
                 Some(6) => {
                     builder.multi_attach_enabled = Some(deser.read_boolean(member)?);
-652
+                }
                 Some(7) => {
                     builder.throughput = Some(deser.read_integer(member)?);
-655
+                }
                 Some(8) => {
                     builder.sse_type = Some(crate::types::SseType::from(deser.read_string(member)?.as_str()));
-658
+                }
                 Some(9) => {
                     builder.operator = Some(crate::types::OperatorResponse::deserialize(deser)?);
-661
+                }
                 Some(10) => {
                     builder.volume_initialization_rate = Some(deser.read_integer(member)?);
-664
+                }
                 Some(11) => {
                     builder.volume_id = Some(deser.read_string(member)?);
-667
+                }
                 Some(12) => {
                     builder.size = Some(deser.read_integer(member)?);
-670
+                }
                 Some(13) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-673
+                }
                 Some(14) => {
                     builder.availability_zone = Some(deser.read_string(member)?);
-676
+                }
                 Some(15) => {
                     builder.state = Some(crate::types::VolumeState::from(deser.read_string(member)?.as_str()));
-679
+                }
                 Some(16) => {
                     builder.create_time = Some(deser.read_timestamp(member)?);
-682
+                }
                 Some(17) => {
                     builder.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::VolumeAttachment::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::VolumeAttachment::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-692
+                }
                 Some(18) => {
                     builder.encrypted = Some(deser.read_boolean(member)?);
-695
+                }
                 Some(19) => {
                     builder.kms_key_id = Some(deser.read_string(member)?);
-698
+                }
                 _ => {}
-700
+            }

↧ Expand context

             Ok(())
         })?;
         Ok(builder.build())
-704
+    }
-705
+}
 impl ::aws_types::request_id::RequestId for CreateVolumeOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-709
+    }
-710
+}
 impl CreateVolumeOutput {
     /// Creates a new builder-style object to manufacture [`CreateVolumeOutput`](crate::operation::create_volume::CreateVolumeOutput).
     pub fn builder() -> crate::operation::create_volume::builders::CreateVolumeOutputBuilder {
         crate::operation::create_volume::builders::CreateVolumeOutputBuilder::default()
-715
+    }
-716
+}
-717
 /// A builder for [`CreateVolumeOutput`](crate::operation::create_volume::CreateVolumeOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `CreateVpc`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateVpc;
 impl CreateVpc {
     /// Creates a new `CreateVpc`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::create_vpc::CreateVpcInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::create_vpc::CreateVpcOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::create_vpc::CreateVpcInput,
     ) -> ::std::result::Result<
         crate::operation::create_vpc::CreateVpcOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::create_vpc::CreateVpcError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::create_vpc::CreateVpcError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::create_vpc::CreateVpcOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -115,119 +177,182 @@

↥ Expand context

         });
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CreateVpc")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateVpcEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_vpc::CreateVpcError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_vpc::CreateVpcError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::create_vpc::CreateVpcError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct CreateVpcResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateVpcResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_create_vpc::de_create_vpc_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_create_vpc::de_create_vpc_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-166
+    }
-167
+}
 #[derive(Debug)]
 struct CreateVpcRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateVpcRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input.downcast::<crate::operation::create_vpc::CreateVpcInput>().expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc/_create_vpc_input.rs

@@ -73,73 +246,246 @@

↥ Expand context

     pub fn tag_specifications(&self) -> &[crate::types::TagSpecification] {
         self.tag_specifications.as_deref().unwrap_or_default()
-75
+    }
     /// <p>Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is <code>DryRunOperation</code>. Otherwise, it is <code>UnauthorizedOperation</code>.</p>
     pub fn dry_run(&self) -> ::std::option::Option<bool> {
         self.dry_run
-79
+    }
     /// <p>The tenancy options for instances launched into the VPC. For <code>default</code>, instances are launched with shared tenancy by default. You can launch instances with any tenancy into a shared tenancy VPC. For <code>dedicated</code>, instances are launched as dedicated tenancy instances by default. You can only launch instances with a tenancy of <code>dedicated</code> or <code>host</code> into a dedicated tenancy VPC.</p>
     /// <p><b>Important:</b> The <code>host</code> value cannot be used with this parameter. Use the <code>default</code> or <code>dedicated</code> values only.</p>
     /// <p>Default: <code>default</code></p>
     pub fn instance_tenancy(&self) -> ::std::option::Option<&crate::types::Tenancy> {
         self.instance_tenancy.as_ref()
-85
+    }
     /// <p>Requests an Amazon-provided IPv6 CIDR block with a /56 prefix length for the VPC. You cannot specify the range of IP addresses, or the size of the CIDR block.</p>
     pub fn amazon_provided_ipv6_cidr_block(&self) -> ::std::option::Option<bool> {
         self.amazon_provided_ipv6_cidr_block
-89
+    }
-90
+}
 static CREATEVPCINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateVpcInput",

     "com.amazonaws.ec2.synthetic",
     "CreateVpcInput",
 );
 static CREATEVPCINPUT_MEMBER_CIDR_BLOCK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcInput$CidrBlock",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "cidr_block",
     "CidrBlock",
 ,
 );
 static CREATEVPCINPUT_MEMBER_IPV6_POOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcInput$Ipv6Pool",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ipv6_pool",
     "Ipv6Pool",
 ,
 );
 static CREATEVPCINPUT_MEMBER_IPV6_CIDR_BLOCK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcInput$Ipv6CidrBlock",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ipv6_cidr_block",
     "Ipv6CidrBlock",
 ,
 );
 static CREATEVPCINPUT_MEMBER_IPV4_IPAM_POOL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcInput$Ipv4IpamPoolId",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ipv4_ipam_pool_id",
     "Ipv4IpamPoolId",
 ,
 );
 static CREATEVPCINPUT_MEMBER_IPV4_NETMASK_LENGTH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcInput$Ipv4NetmaskLength",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "ipv4_netmask_length",
     "Ipv4NetmaskLength",
 ,
 );
 static CREATEVPCINPUT_MEMBER_IPV6_IPAM_POOL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcInput$Ipv6IpamPoolId",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ipv6_ipam_pool_id",
     "Ipv6IpamPoolId",
 ,
 );
 static CREATEVPCINPUT_MEMBER_IPV6_NETMASK_LENGTH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcInput$Ipv6NetmaskLength",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "ipv6_netmask_length",
     "Ipv6NetmaskLength",
 ,
 );
 static CREATEVPCINPUT_MEMBER_IPV6_CIDR_BLOCK_NETWORK_BORDER_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcInput$Ipv6CidrBlockNetworkBorderGroup",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ipv6_cidr_block_network_border_group",
     "Ipv6CidrBlockNetworkBorderGroup",
 ,
 );
 static CREATEVPCINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcInput$TagSpecifications",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_specifications",
     "TagSpecifications",
 ,
-185
+)
 .with_xml_name("TagSpecification");
 static CREATEVPCINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
-196
+)
 .with_xml_name("dryRun");
 static CREATEVPCINPUT_MEMBER_INSTANCE_TENANCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcInput$InstanceTenancy",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_tenancy",
     "InstanceTenancy",
 ,
-207
+)
 .with_xml_name("instanceTenancy");
 static CREATEVPCINPUT_MEMBER_AMAZON_PROVIDED_IPV6_CIDR_BLOCK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcInput$AmazonProvidedIpv6CidrBlock",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "amazon_provided_ipv6_cidr_block",
     "AmazonProvidedIpv6CidrBlock",
 ,
-218
+)
 .with_xml_name("amazonProvidedIpv6CidrBlock");
 static CREATEVPCINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEVPCINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEVPCINPUT_MEMBER_CIDR_BLOCK,
         &CREATEVPCINPUT_MEMBER_IPV6_POOL,
         &CREATEVPCINPUT_MEMBER_IPV6_CIDR_BLOCK,

↧ Expand context

         &CREATEVPCINPUT_MEMBER_IPV4_IPAM_POOL_ID,
         &CREATEVPCINPUT_MEMBER_IPV4_NETMASK_LENGTH,
         &CREATEVPCINPUT_MEMBER_IPV6_IPAM_POOL_ID,
         &CREATEVPCINPUT_MEMBER_IPV6_NETMASK_LENGTH,
         &CREATEVPCINPUT_MEMBER_IPV6_CIDR_BLOCK_NETWORK_BORDER_GROUP,
         &CREATEVPCINPUT_MEMBER_TAG_SPECIFICATIONS,
         &CREATEVPCINPUT_MEMBER_DRY_RUN,
         &CREATEVPCINPUT_MEMBER_INSTANCE_TENANCY,
         &CREATEVPCINPUT_MEMBER_AMAZON_PROVIDED_IPV6_CIDR_BLOCK,
     ],
 );
 impl CreateVpcInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVPCINPUT_SCHEMA;
-241
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateVpcInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,

@@ -267,267 +395,403 @@

↥ Expand context

             ser.write_integer(&CREATEVPCINPUT_MEMBER_IPV6_NETMASK_LENGTH, *val)?;
-268
+        }
         if let Some(ref val) = self.ipv6_cidr_block_network_border_group {
             ser.write_string(&CREATEVPCINPUT_MEMBER_IPV6_CIDR_BLOCK_NETWORK_BORDER_GROUP, val)?;
-271
+        }
         if let Some(ref val) = self.tag_specifications {
             ser.write_list(
                 &CREATEVPCINPUT_MEMBER_TAG_SPECIFICATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
-278
+                    }
                     Ok(())
                 },
             )?;
-282
+        }
         if let Some(ref val) = self.dry_run {
             ser.write_boolean(&CREATEVPCINPUT_MEMBER_DRY_RUN, *val)?;
-285
+        }
         if let Some(ref val) = self.instance_tenancy {

             ser.write_string(&CREATEVPCINPUT_MEMBER_INSTANCE_TENANCY, val.as_str())?;
-288
+        }
         if let Some(ref val) = self.amazon_provided_ipv6_cidr_block {
             ser.write_boolean(&CREATEVPCINPUT_MEMBER_AMAZON_PROVIDED_IPV6_CIDR_BLOCK, *val)?;
-291
+        }
         Ok(())
-293
+    }
-294
+}
 impl CreateVpcInput {
     /// 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(&CREATEVPCINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEVPCINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.cidr_block = Some(deser.read_string(member)?);
-313
+                }
                 Some(1) => {
                     builder.ipv6_pool = Some(deser.read_string(member)?);
-316
+                }
                 Some(2) => {
                     builder.ipv6_cidr_block = Some(deser.read_string(member)?);
-319
+                }
                 Some(3) => {
                     builder.ipv4_ipam_pool_id = Some(deser.read_string(member)?);
-322
+                }
                 Some(4) => {
                     builder.ipv4_netmask_length = Some(deser.read_integer(member)?);
-325
+                }
                 Some(5) => {
                     builder.ipv6_ipam_pool_id = Some(deser.read_string(member)?);
-328
+                }
                 Some(6) => {
                     builder.ipv6_netmask_length = Some(deser.read_integer(member)?);
-331
+                }
                 Some(7) => {
                     builder.ipv6_cidr_block_network_border_group = Some(deser.read_string(member)?);
-334
+                }
                 Some(8) => {
                     builder.tag_specifications = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-344
+                }
                 Some(9) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-347
+                }
                 Some(10) => {
                     builder.instance_tenancy = Some(crate::types::Tenancy::from(deser.read_string(member)?.as_str()));
-350
+                }
                 Some(11) => {
                     builder.amazon_provided_ipv6_cidr_block = Some(deser.read_boolean(member)?);
-353
+                }
                 _ => {}
-355
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-361
+    }
-362
+}
 impl CreateVpcInput {
     /// 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 CreateVpcInput {
     /// Creates a new builder-style object to manufacture [`CreateVpcInput`](crate::operation::create_vpc::CreateVpcInput).
     pub fn builder() -> crate::operation::create_vpc::builders::CreateVpcInputBuilder {
         crate::operation::create_vpc::builders::CreateVpcInputBuilder::default()
-378
+    }
-379
+}
-380
 /// A builder for [`CreateVpcInput`](crate::operation::create_vpc::CreateVpcInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CreateVpcInputBuilder {
     pub(crate) cidr_block: ::std::option::Option<::std::string::String>,
     pub(crate) ipv6_pool: ::std::option::Option<::std::string::String>,
     pub(crate) ipv6_cidr_block: ::std::option::Option<::std::string::String>,
     pub(crate) ipv4_ipam_pool_id: ::std::option::Option<::std::string::String>,
     pub(crate) ipv4_netmask_length: ::std::option::Option<i32>,
     pub(crate) ipv6_ipam_pool_id: ::std::option::Option<::std::string::String>,
     pub(crate) ipv6_netmask_length: ::std::option::Option<i32>,
     pub(crate) ipv6_cidr_block_network_border_group: ::std::option::Option<::std::string::String>,
     pub(crate) tag_specifications: ::std::option::Option<::std::vec::Vec<crate::types::TagSpecification>>,
     pub(crate) dry_run: ::std::option::Option<bool>,
     pub(crate) instance_tenancy: ::std::option::Option<crate::types::Tenancy>,
     pub(crate) amazon_provided_ipv6_cidr_block: ::std::option::Option<bool>,
-397
+}
 impl CreateVpcInputBuilder {
     /// <p>The IPv4 network range for the VPC, in CIDR notation. For example, <code>10.0.0.0/16</code>. We modify the specified CIDR block to its canonical form; for example, if you specify <code>100.68.0.18/18</code>, we modify it to <code>100.68.0.0/18</code>.</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
-403
+    }

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc/_create_vpc_output.rs

@@ -1,1 +97,141 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct CreateVpcOutput {
     /// <p>Information about the VPC.</p>
     pub vpc: ::std::option::Option<crate::types::Vpc>,
     _request_id: Option<String>,
-9
+}
 impl CreateVpcOutput {
     /// <p>Information about the VPC.</p>
     pub fn vpc(&self) -> ::std::option::Option<&crate::types::Vpc> {
         self.vpc.as_ref()
-14
+    }
-15
+}
 static CREATEVPCOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateVpcOutput",

     "com.amazonaws.ec2.synthetic",
     "CreateVpcOutput",
 );
 static CREATEVPCOUTPUT_MEMBER_VPC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcOutput$Vpc",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "vpc",
     "Vpc",
 ,
-30
+)
 .with_xml_name("vpc");
 static CREATEVPCOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static CREATEVPCOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEVPCOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CREATEVPCOUTPUT_MEMBER_VPC],
     &[&CREATEVPCOUTPUT_MEMBER_VPC, &CREATEVPCOUTPUT_MEMBER__REQUEST_ID],
 );
 impl CreateVpcOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVPCOUTPUT_SCHEMA;
-47
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateVpcOutput {
     #[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.vpc {
             ser.write_struct(&CREATEVPCOUTPUT_MEMBER_VPC, val)?;
-56
+        }
         Ok(())
-58
+    }
-59
+}
 impl CreateVpcOutput {
     /// 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(&CREATEVPCOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEVPCOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.vpc = Some(crate::types::Vpc::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateVpcOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATEVPCOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.vpc = Some(crate::types::Vpc::deserialize(deser)?);
-115
+                }
                 _ => {}
-117
+            }
             Ok(())
         })?;
         Ok(builder.build())
-121
+    }

↧ Expand context

-122
+}
 impl ::aws_types::request_id::RequestId for CreateVpcOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-126
+    }
-127
+}
 impl CreateVpcOutput {
     /// Creates a new builder-style object to manufacture [`CreateVpcOutput`](crate::operation::create_vpc::CreateVpcOutput).
     pub fn builder() -> crate::operation::create_vpc::builders::CreateVpcOutputBuilder {
         crate::operation::create_vpc::builders::CreateVpcOutputBuilder::default()
-132
+    }
-133
+}
-134
 /// A builder for [`CreateVpcOutput`](crate::operation::create_vpc::CreateVpcOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateVpcOutputBuilder {
     pub(crate) vpc: ::std::option::Option<crate::types::Vpc>,
     _request_id: Option<String>,
-141
+}

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc_block_public_access_exclusion.rs

@@ -1,1 +40,46 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `CreateVpcBlockPublicAccessExclusion`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateVpcBlockPublicAccessExclusion;
 impl CreateVpcBlockPublicAccessExclusion {
     /// Creates a new `CreateVpcBlockPublicAccessExclusion`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionInput,
     ) -> ::std::result::Result<
         crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -124,130 +186,193 @@

↥ Expand context

         });
-131
         ::std::option::Option::Some(cfg.freeze())
-133
+    }
-134
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CreateVpcBlockPublicAccessExclusion")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateVpcBlockPublicAccessExclusionEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionError,
             >::new());
-152
         ::std::borrow::Cow::Owned(rcb)
-154
+    }
-155
+}
-156
 #[derive(Debug)]
 struct CreateVpcBlockPublicAccessExclusionResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateVpcBlockPublicAccessExclusionResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_create_vpc_block_public_access_exclusion::de_create_vpc_block_public_access_exclusion_http_error(
                 status, headers, body,

↧ Expand context

-174
+            )
         } else {
             crate::protocol_serde::shape_create_vpc_block_public_access_exclusion::de_create_vpc_block_public_access_exclusion_http_response(
                 status, headers, body,
-178
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
-181
+    }
-182
+}
 #[derive(Debug)]
 struct CreateVpcBlockPublicAccessExclusionRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateVpcBlockPublicAccessExclusionRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionInput>()

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc_block_public_access_exclusion/_create_vpc_block_public_access_exclusion_input.rs

@@ -35,35 +240,248 @@

↥ Expand context

-35
+    }
     /// <p>The exclusion mode for internet gateway traffic.</p>
     /// <ul>
     /// <li>
     /// <p><code>allow-bidirectional</code>: Allow all internet traffic to and from the excluded VPCs and subnets.</p></li>
     /// <li>
     /// <p><code>allow-egress</code>: Allow outbound internet traffic from the excluded VPCs and subnets. Block inbound internet traffic to the excluded VPCs and subnets. Only applies when VPC Block Public Access is set to Bidirectional.</p></li>
     /// </ul>
     pub fn internet_gateway_exclusion_mode(&self) -> ::std::option::Option<&crate::types::InternetGatewayExclusionMode> {
         self.internet_gateway_exclusion_mode.as_ref()
-45
+    }
     /// <p><code>tag</code> - The key/value combination of a tag assigned to the resource. Use the tag key in the filter name and the tag value as the filter value. For example, to find all resources that have a tag with the key <code>Owner</code> and the value <code>TeamA</code>, specify <code>tag:Owner</code> for the filter name and <code>TeamA</code> for the filter value.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tag_specifications.is_none()`.
     pub fn tag_specifications(&self) -> &[crate::types::TagSpecification] {
         self.tag_specifications.as_deref().unwrap_or_default()
-51
+    }
-52
+}
 static CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateVpcBlockPublicAccessExclusionInput",

     "com.amazonaws.ec2.synthetic",
     "CreateVpcBlockPublicAccessExclusionInput",
 );
 static CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcBlockPublicAccessExclusionInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcBlockPublicAccessExclusionInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcBlockPublicAccessExclusionInput$SubnetId",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcBlockPublicAccessExclusionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "subnet_id",
     "SubnetId",
 ,
 );
 static CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcBlockPublicAccessExclusionInput$VpcId",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcBlockPublicAccessExclusionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpc_id",
     "VpcId",
 ,
 );
 static CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_INTERNET_GATEWAY_EXCLUSION_MODE: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#CreateVpcBlockPublicAccessExclusionInput$InternetGatewayExclusionMode",
             "com.amazonaws.ec2.synthetic",
             "CreateVpcBlockPublicAccessExclusionInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "internet_gateway_exclusion_mode",
         "InternetGatewayExclusionMode",
 ,
     );
 static CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcBlockPublicAccessExclusionInput$TagSpecifications",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcBlockPublicAccessExclusionInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_specifications",
     "TagSpecifications",
 ,
-108
+)
 .with_xml_name("TagSpecification");
 static CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_DRY_RUN,
         &CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_SUBNET_ID,
         &CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_VPC_ID,
         &CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_INTERNET_GATEWAY_EXCLUSION_MODE,
         &CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_TAG_SPECIFICATIONS,
     ],
 );
 impl CreateVpcBlockPublicAccessExclusionInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_SCHEMA;
-124
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateVpcBlockPublicAccessExclusionInput {
     #[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.dry_run {
             ser.write_boolean(&CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_DRY_RUN, *val)?;
-133
+        }
         if let Some(ref val) = self.subnet_id {
             ser.write_string(&CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_SUBNET_ID, val)?;
-136
+        }
         if let Some(ref val) = self.vpc_id {
             ser.write_string(&CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_VPC_ID, val)?;
-139
+        }
         if let Some(ref val) = self.internet_gateway_exclusion_mode {
             ser.write_string(
                 &CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_INTERNET_GATEWAY_EXCLUSION_MODE,
                 val.as_str(),
             )?;
-145
+        }
         if let Some(ref val) = self.tag_specifications {
             ser.write_list(
                 &CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_MEMBER_TAG_SPECIFICATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
-152
+                    }
                     Ok(())
                 },
             )?;
-156
+        }
         Ok(())
-158
+    }
-159
+}
 impl CreateVpcBlockPublicAccessExclusionInput {
     /// 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(&CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEVPCBLOCKPUBLICACCESSEXCLUSIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-178
+                }
                 Some(1) => {
                     builder.subnet_id = Some(deser.read_string(member)?);
-181
+                }
                 Some(2) => {
                     builder.vpc_id = Some(deser.read_string(member)?);
-184
+                }
                 Some(3) => {
                     builder.internet_gateway_exclusion_mode =
                         Some(crate::types::InternetGatewayExclusionMode::from(deser.read_string(member)?.as_str()));
-188
+                }
                 Some(4) => {
                     builder.tag_specifications = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-198
+                }
                 _ => {}
-200
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-206
+    }
-207
+}
 impl CreateVpcBlockPublicAccessExclusionInput {
     /// 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 CreateVpcBlockPublicAccessExclusionInput {
     /// Creates a new builder-style object to manufacture [`CreateVpcBlockPublicAccessExclusionInput`](crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionInput).
     pub fn builder() -> crate::operation::create_vpc_block_public_access_exclusion::builders::CreateVpcBlockPublicAccessExclusionInputBuilder {
         crate::operation::create_vpc_block_public_access_exclusion::builders::CreateVpcBlockPublicAccessExclusionInputBuilder::default()
-223
+    }
-224
+}
-225
 /// A builder for [`CreateVpcBlockPublicAccessExclusionInput`](crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CreateVpcBlockPublicAccessExclusionInputBuilder {
     pub(crate) dry_run: ::std::option::Option<bool>,
     pub(crate) subnet_id: ::std::option::Option<::std::string::String>,
     pub(crate) vpc_id: ::std::option::Option<::std::string::String>,
     pub(crate) internet_gateway_exclusion_mode: ::std::option::Option<crate::types::InternetGatewayExclusionMode>,
     pub(crate) tag_specifications: ::std::option::Option<::std::vec::Vec<crate::types::TagSpecification>>,
-235
+}
 impl CreateVpcBlockPublicAccessExclusionInputBuilder {
     /// <p>Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is <code>DryRunOperation</code>. Otherwise, it is <code>UnauthorizedOperation</code>.</p>
     pub fn dry_run(mut self, input: bool) -> Self {
         self.dry_run = ::std::option::Option::Some(input);
         self
-241
+    }
     /// <p>Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is <code>DryRunOperation</code>. Otherwise, it is <code>UnauthorizedOperation</code>.</p>
     pub fn set_dry_run(mut self, input: ::std::option::Option<bool>) -> Self {
         self.dry_run = input;
         self
-246
+    }
     /// <p>Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is <code>DryRunOperation</code>. Otherwise, it is <code>UnauthorizedOperation</code>.</p>
     pub fn get_dry_run(&self) -> &::std::option::Option<bool> {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc_block_public_access_exclusion/_create_vpc_block_public_access_exclusion_output.rs

@@ -1,1 +98,145 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct CreateVpcBlockPublicAccessExclusionOutput {
     /// <p>Details about an exclusion.</p>
     pub vpc_block_public_access_exclusion: ::std::option::Option<crate::types::VpcBlockPublicAccessExclusion>,
     _request_id: Option<String>,
-9
+}
 impl CreateVpcBlockPublicAccessExclusionOutput {
     /// <p>Details about an exclusion.</p>
     pub fn vpc_block_public_access_exclusion(&self) -> ::std::option::Option<&crate::types::VpcBlockPublicAccessExclusion> {
         self.vpc_block_public_access_exclusion.as_ref()
-14
+    }
-15
+}
 static CREATEVPCBLOCKPUBLICACCESSEXCLUSIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateVpcBlockPublicAccessExclusionOutput",
     "com.amazonaws.ec2.synthetic",

     "CreateVpcBlockPublicAccessExclusionOutput",
 );
 static CREATEVPCBLOCKPUBLICACCESSEXCLUSIONOUTPUT_MEMBER_VPC_BLOCK_PUBLIC_ACCESS_EXCLUSION: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#CreateVpcBlockPublicAccessExclusionOutput$VpcBlockPublicAccessExclusion",
             "com.amazonaws.ec2.synthetic",
             "CreateVpcBlockPublicAccessExclusionOutput",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "vpc_block_public_access_exclusion",
         "VpcBlockPublicAccessExclusion",
 ,
-31
+    )
     .with_xml_name("vpcBlockPublicAccessExclusion");
 static CREATEVPCBLOCKPUBLICACCESSEXCLUSIONOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static CREATEVPCBLOCKPUBLICACCESSEXCLUSIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEVPCBLOCKPUBLICACCESSEXCLUSIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CREATEVPCBLOCKPUBLICACCESSEXCLUSIONOUTPUT_MEMBER_VPC_BLOCK_PUBLIC_ACCESS_EXCLUSION],
     &[
         &CREATEVPCBLOCKPUBLICACCESSEXCLUSIONOUTPUT_MEMBER_VPC_BLOCK_PUBLIC_ACCESS_EXCLUSION,
         &CREATEVPCBLOCKPUBLICACCESSEXCLUSIONOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl CreateVpcBlockPublicAccessExclusionOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVPCBLOCKPUBLICACCESSEXCLUSIONOUTPUT_SCHEMA;
-51
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateVpcBlockPublicAccessExclusionOutput {
     #[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.vpc_block_public_access_exclusion {
             ser.write_struct(&CREATEVPCBLOCKPUBLICACCESSEXCLUSIONOUTPUT_MEMBER_VPC_BLOCK_PUBLIC_ACCESS_EXCLUSION, val)?;
-60
+        }
         Ok(())
-62
+    }
-63
+}
 impl CreateVpcBlockPublicAccessExclusionOutput {
     /// 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(&CREATEVPCBLOCKPUBLICACCESSEXCLUSIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEVPCBLOCKPUBLICACCESSEXCLUSIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.vpc_block_public_access_exclusion = Some(crate::types::VpcBlockPublicAccessExclusion::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateVpcBlockPublicAccessExclusionOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATEVPCBLOCKPUBLICACCESSEXCLUSIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.vpc_block_public_access_exclusion = Some(crate::types::VpcBlockPublicAccessExclusion::deserialize(deser)?);
-119
+                }
                 _ => {}
-121
+            }
             Ok(())
         })?;
         Ok(builder.build())
-125
+    }

↧ Expand context

-126
+}
 impl ::aws_types::request_id::RequestId for CreateVpcBlockPublicAccessExclusionOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-130
+    }
-131
+}
 impl CreateVpcBlockPublicAccessExclusionOutput {
     /// Creates a new builder-style object to manufacture [`CreateVpcBlockPublicAccessExclusionOutput`](crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionOutput).
     pub fn builder() -> crate::operation::create_vpc_block_public_access_exclusion::builders::CreateVpcBlockPublicAccessExclusionOutputBuilder {
         crate::operation::create_vpc_block_public_access_exclusion::builders::CreateVpcBlockPublicAccessExclusionOutputBuilder::default()
-136
+    }
-137
+}
-138
 /// A builder for [`CreateVpcBlockPublicAccessExclusionOutput`](crate::operation::create_vpc_block_public_access_exclusion::CreateVpcBlockPublicAccessExclusionOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateVpcBlockPublicAccessExclusionOutputBuilder {
     pub(crate) vpc_block_public_access_exclusion: ::std::option::Option<crate::types::VpcBlockPublicAccessExclusion>,
     _request_id: Option<String>,
-145
+}

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc_endpoint.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `CreateVpcEndpoint`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateVpcEndpoint;
 impl CreateVpcEndpoint {
     /// Creates a new `CreateVpcEndpoint`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::create_vpc_endpoint::CreateVpcEndpointInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::create_vpc_endpoint::CreateVpcEndpointOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::create_vpc_endpoint::CreateVpcEndpointInput,
     ) -> ::std::result::Result<
         crate::operation::create_vpc_endpoint::CreateVpcEndpointOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::create_vpc_endpoint::CreateVpcEndpointError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::create_vpc_endpoint::CreateVpcEndpointError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::create_vpc_endpoint::CreateVpcEndpointOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -115,119 +177,182 @@

↥ Expand context

         });
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CreateVpcEndpoint")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateVpcEndpointEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_vpc_endpoint::CreateVpcEndpointError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_vpc_endpoint::CreateVpcEndpointError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::create_vpc_endpoint::CreateVpcEndpointError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct CreateVpcEndpointResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateVpcEndpointResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_create_vpc_endpoint::de_create_vpc_endpoint_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_create_vpc_endpoint::de_create_vpc_endpoint_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-166
+    }
-167
+}
 #[derive(Debug)]
 struct CreateVpcEndpointRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateVpcEndpointRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::create_vpc_endpoint::CreateVpcEndpointInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc_endpoint/_create_vpc_endpoint_input.rs

@@ -107,107 +332,332 @@

↥ Expand context

     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.subnet_configurations.is_none()`.
     pub fn subnet_configurations(&self) -> &[crate::types::SubnetConfiguration] {
         self.subnet_configurations.as_deref().unwrap_or_default()
-111
+    }
     /// <p>The Amazon Resource Name (ARN) of a service network that will be associated with the VPC endpoint of type service-network.</p>
     pub fn service_network_arn(&self) -> ::std::option::Option<&str> {
         self.service_network_arn.as_deref()
-115
+    }
     /// <p>The Amazon Resource Name (ARN) of a resource configuration that will be associated with the VPC endpoint of type resource.</p>
     pub fn resource_configuration_arn(&self) -> ::std::option::Option<&str> {
         self.resource_configuration_arn.as_deref()
-119
+    }
     /// <p>The Region where the service is hosted. The default is the current Region.</p>
     pub fn service_region(&self) -> ::std::option::Option<&str> {
         self.service_region.as_deref()
-123
+    }
-124
+}
 static CREATEVPCENDPOINTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput",

     "com.amazonaws.ec2.synthetic",
     "CreateVpcEndpointInput",
 );
 static CREATEVPCENDPOINTINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static CREATEVPCENDPOINTINPUT_MEMBER_VPC_ENDPOINT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$VpcEndpointType",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpc_endpoint_type",
     "VpcEndpointType",
 ,
 );
 static CREATEVPCENDPOINTINPUT_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$VpcId",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpc_id",
     "VpcId",
 ,
 );
 static CREATEVPCENDPOINTINPUT_MEMBER_SERVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$ServiceName",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "service_name",
     "ServiceName",
 ,
 );
 static CREATEVPCENDPOINTINPUT_MEMBER_POLICY_DOCUMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$PolicyDocument",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "policy_document",
     "PolicyDocument",
 ,
 );
 static CREATEVPCENDPOINTINPUT_MEMBER_ROUTE_TABLE_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$RouteTableIds",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "route_table_ids",
     "RouteTableIds",
 ,
-189
+)
 .with_xml_name("RouteTableId");
 static CREATEVPCENDPOINTINPUT_MEMBER_SUBNET_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$SubnetIds",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "subnet_ids",
     "SubnetIds",
 ,
-200
+)
 .with_xml_name("SubnetId");
 static CREATEVPCENDPOINTINPUT_MEMBER_SECURITY_GROUP_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$SecurityGroupIds",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "security_group_ids",
     "SecurityGroupIds",
 ,
-211
+)
 .with_xml_name("SecurityGroupId");
 static CREATEVPCENDPOINTINPUT_MEMBER_IP_ADDRESS_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$IpAddressType",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ip_address_type",
     "IpAddressType",
 ,
 );
 static CREATEVPCENDPOINTINPUT_MEMBER_DNS_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$DnsOptions",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "dns_options",
     "DnsOptions",
 ,
 );
 static CREATEVPCENDPOINTINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$ClientToken",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
 );
 static CREATEVPCENDPOINTINPUT_MEMBER_PRIVATE_DNS_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$PrivateDnsEnabled",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "private_dns_enabled",
     "PrivateDnsEnabled",
 ,
 );
 static CREATEVPCENDPOINTINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$TagSpecifications",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_specifications",
     "TagSpecifications",
 ,
-262
+)
 .with_xml_name("TagSpecification");
 static CREATEVPCENDPOINTINPUT_MEMBER_SUBNET_CONFIGURATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$SubnetConfigurations",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "subnet_configurations",
     "SubnetConfigurations",
 ,
-273
+)
 .with_xml_name("SubnetConfiguration");
 static CREATEVPCENDPOINTINPUT_MEMBER_SERVICE_NETWORK_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$ServiceNetworkArn",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "service_network_arn",
     "ServiceNetworkArn",
 ,
 );
 static CREATEVPCENDPOINTINPUT_MEMBER_RESOURCE_CONFIGURATION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$ResourceConfigurationArn",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_configuration_arn",
     "ResourceConfigurationArn",
 ,
 );
 static CREATEVPCENDPOINTINPUT_MEMBER_SERVICE_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointInput$ServiceRegion",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "service_region",
     "ServiceRegion",
 ,
 );
 static CREATEVPCENDPOINTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEVPCENDPOINTINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEVPCENDPOINTINPUT_MEMBER_DRY_RUN,
         &CREATEVPCENDPOINTINPUT_MEMBER_VPC_ENDPOINT_TYPE,
         &CREATEVPCENDPOINTINPUT_MEMBER_VPC_ID,
         &CREATEVPCENDPOINTINPUT_MEMBER_SERVICE_NAME,

↧ Expand context

         &CREATEVPCENDPOINTINPUT_MEMBER_POLICY_DOCUMENT,
         &CREATEVPCENDPOINTINPUT_MEMBER_ROUTE_TABLE_IDS,
         &CREATEVPCENDPOINTINPUT_MEMBER_SUBNET_IDS,
         &CREATEVPCENDPOINTINPUT_MEMBER_SECURITY_GROUP_IDS,
         &CREATEVPCENDPOINTINPUT_MEMBER_IP_ADDRESS_TYPE,
         &CREATEVPCENDPOINTINPUT_MEMBER_DNS_OPTIONS,
         &CREATEVPCENDPOINTINPUT_MEMBER_CLIENT_TOKEN,
         &CREATEVPCENDPOINTINPUT_MEMBER_PRIVATE_DNS_ENABLED,
         &CREATEVPCENDPOINTINPUT_MEMBER_TAG_SPECIFICATIONS,
         &CREATEVPCENDPOINTINPUT_MEMBER_SUBNET_CONFIGURATIONS,
         &CREATEVPCENDPOINTINPUT_MEMBER_SERVICE_NETWORK_ARN,
         &CREATEVPCENDPOINTINPUT_MEMBER_RESOURCE_CONFIGURATION_ARN,
         &CREATEVPCENDPOINTINPUT_MEMBER_SERVICE_REGION,
     ],
 );
 impl CreateVpcEndpointInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVPCENDPOINTINPUT_SCHEMA;
-331
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateVpcEndpointInput {

@@ -404,404 +587,563 @@

↥ Expand context

-404
+                    }
                     Ok(())
                 },
             )?;
-408
+        }
         if let Some(ref val) = self.subnet_configurations {
             ser.write_list(
                 &CREATEVPCENDPOINTINPUT_MEMBER_SUBNET_CONFIGURATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::SubnetConfiguration::SCHEMA, item)?;
-415
+                    }
                     Ok(())
                 },
             )?;
-419
+        }
         if let Some(ref val) = self.service_network_arn {
             ser.write_string(&CREATEVPCENDPOINTINPUT_MEMBER_SERVICE_NETWORK_ARN, val)?;
-422
+        }
         if let Some(ref val) = self.resource_configuration_arn {

             ser.write_string(&CREATEVPCENDPOINTINPUT_MEMBER_RESOURCE_CONFIGURATION_ARN, val)?;
-425
+        }
         if let Some(ref val) = self.service_region {
             ser.write_string(&CREATEVPCENDPOINTINPUT_MEMBER_SERVICE_REGION, val)?;
-428
+        }
         Ok(())
-430
+    }
-431
+}
 impl CreateVpcEndpointInput {
     /// 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(&CREATEVPCENDPOINTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEVPCENDPOINTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-450
+                }
                 Some(1) => {
                     builder.vpc_endpoint_type = Some(crate::types::VpcEndpointType::from(deser.read_string(member)?.as_str()));
-453
+                }
                 Some(2) => {
                     builder.vpc_id = Some(deser.read_string(member)?);
-456
+                }
                 Some(3) => {
                     builder.service_name = Some(deser.read_string(member)?);
-459
+                }
                 Some(4) => {
                     builder.policy_document = Some(deser.read_string(member)?);
-462
+                }
                 Some(5) => {
                     builder.route_table_ids = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.route_table_ids = Some(deser.read_string_list(member)?);
-465
+                }
                 Some(6) => {
                     builder.subnet_ids = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.subnet_ids = Some(deser.read_string_list(member)?);
-468
+                }
                 Some(7) => {
                     builder.security_group_ids = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.security_group_ids = Some(deser.read_string_list(member)?);
-471
+                }
                 Some(8) => {
                     builder.ip_address_type = Some(crate::types::IpAddressType::from(deser.read_string(member)?.as_str()));
-474
+                }
                 Some(9) => {
                     builder.dns_options = Some(crate::types::DnsOptionsSpecification::deserialize(deser)?);
-477
+                }
                 Some(10) => {
                     builder.client_token = Some(deser.read_string(member)?);
-480
+                }
                 Some(11) => {
                     builder.private_dns_enabled = Some(deser.read_boolean(member)?);
-483
+                }
                 Some(12) => {
                     builder.tag_specifications = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-493
+                }
                 Some(13) => {
                     builder.subnet_configurations = 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::SubnetConfiguration::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::SubnetConfiguration::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-503
+                }
                 Some(14) => {
                     builder.service_network_arn = Some(deser.read_string(member)?);
-506
+                }
                 Some(15) => {
                     builder.resource_configuration_arn = Some(deser.read_string(member)?);
-509
+                }
                 Some(16) => {
                     builder.service_region = Some(deser.read_string(member)?);
-512
+                }
                 _ => {}
-514
+            }
             Ok(())
         })?;
         builder.vpc_id = builder.vpc_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-521
+    }
-522
+}
 impl CreateVpcEndpointInput {
     /// 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 CreateVpcEndpointInput {
     /// Creates a new builder-style object to manufacture [`CreateVpcEndpointInput`](crate::operation::create_vpc_endpoint::CreateVpcEndpointInput).
     pub fn builder() -> crate::operation::create_vpc_endpoint::builders::CreateVpcEndpointInputBuilder {
         crate::operation::create_vpc_endpoint::builders::CreateVpcEndpointInputBuilder::default()
-538
+    }
-539
+}
-540
 /// A builder for [`CreateVpcEndpointInput`](crate::operation::create_vpc_endpoint::CreateVpcEndpointInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CreateVpcEndpointInputBuilder {
     pub(crate) dry_run: ::std::option::Option<bool>,
     pub(crate) vpc_endpoint_type: ::std::option::Option<crate::types::VpcEndpointType>,
     pub(crate) vpc_id: ::std::option::Option<::std::string::String>,
     pub(crate) service_name: ::std::option::Option<::std::string::String>,
     pub(crate) policy_document: ::std::option::Option<::std::string::String>,
     pub(crate) route_table_ids: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) subnet_ids: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) security_group_ids: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) ip_address_type: ::std::option::Option<crate::types::IpAddressType>,
     pub(crate) dns_options: ::std::option::Option<crate::types::DnsOptionsSpecification>,
     pub(crate) client_token: ::std::option::Option<::std::string::String>,
     pub(crate) private_dns_enabled: ::std::option::Option<bool>,
     pub(crate) tag_specifications: ::std::option::Option<::std::vec::Vec<crate::types::TagSpecification>>,
     pub(crate) subnet_configurations: ::std::option::Option<::std::vec::Vec<crate::types::SubnetConfiguration>>,
     pub(crate) service_network_arn: ::std::option::Option<::std::string::String>,
     pub(crate) resource_configuration_arn: ::std::option::Option<::std::string::String>,
     pub(crate) service_region: ::std::option::Option<::std::string::String>,
-562
+}
 impl CreateVpcEndpointInputBuilder {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc_endpoint/_create_vpc_endpoint_output.rs

@@ -4,4 +117,168 @@

↥ Expand context

 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct CreateVpcEndpointOutput {
     /// <p>Information about the endpoint.</p>
     pub vpc_endpoint: ::std::option::Option<crate::types::VpcEndpoint>,
     /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.</p>
     pub client_token: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-11
+}
 impl CreateVpcEndpointOutput {
     /// <p>Information about the endpoint.</p>
     pub fn vpc_endpoint(&self) -> ::std::option::Option<&crate::types::VpcEndpoint> {
         self.vpc_endpoint.as_ref()
-16
+    }
     /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.</p>
     pub fn client_token(&self) -> ::std::option::Option<&str> {
         self.client_token.as_deref()
-20
+    }
-21
+}
 static CREATEVPCENDPOINTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateVpcEndpointOutput",

     "com.amazonaws.ec2.synthetic",
     "CreateVpcEndpointOutput",
 );
 static CREATEVPCENDPOINTOUTPUT_MEMBER_VPC_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointOutput$VpcEndpoint",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "vpc_endpoint",
     "VpcEndpoint",
 ,
-36
+)
 .with_xml_name("vpcEndpoint");
 static CREATEVPCENDPOINTOUTPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointOutput$ClientToken",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
-47
+)
 .with_xml_name("clientToken");
 static CREATEVPCENDPOINTOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static CREATEVPCENDPOINTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEVPCENDPOINTOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CREATEVPCENDPOINTOUTPUT_MEMBER_VPC_ENDPOINT, &CREATEVPCENDPOINTOUTPUT_MEMBER_CLIENT_TOKEN],
     &[
         &CREATEVPCENDPOINTOUTPUT_MEMBER_VPC_ENDPOINT,
         &CREATEVPCENDPOINTOUTPUT_MEMBER_CLIENT_TOKEN,
         &CREATEVPCENDPOINTOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl CreateVpcEndpointOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVPCENDPOINTOUTPUT_SCHEMA;
-68
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateVpcEndpointOutput {
     #[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.vpc_endpoint {
             ser.write_struct(&CREATEVPCENDPOINTOUTPUT_MEMBER_VPC_ENDPOINT, val)?;
-77
+        }
         if let Some(ref val) = self.client_token {
             ser.write_string(&CREATEVPCENDPOINTOUTPUT_MEMBER_CLIENT_TOKEN, val)?;
-80
+        }
         Ok(())
-82
+    }
-83
+}
 impl CreateVpcEndpointOutput {
     /// 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(&CREATEVPCENDPOINTOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEVPCENDPOINTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.vpc_endpoint = Some(crate::types::VpcEndpoint::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder.client_token = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateVpcEndpointOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATEVPCENDPOINTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.vpc_endpoint = Some(crate::types::VpcEndpoint::deserialize(deser)?);
-142
+                }
                 Some(1) => {
                     builder.client_token = Some(deser.read_string(member)?);
-145
+                }
                 _ => {}
-147
+            }
             Ok(())

↧ Expand context

         })?;
         Ok(builder.build())
-151
+    }
-152
+}
 impl ::aws_types::request_id::RequestId for CreateVpcEndpointOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-156
+    }
-157
+}
 impl CreateVpcEndpointOutput {
     /// Creates a new builder-style object to manufacture [`CreateVpcEndpointOutput`](crate::operation::create_vpc_endpoint::CreateVpcEndpointOutput).
     pub fn builder() -> crate::operation::create_vpc_endpoint::builders::CreateVpcEndpointOutputBuilder {
         crate::operation::create_vpc_endpoint::builders::CreateVpcEndpointOutputBuilder::default()
-162
+    }
-163
+}
-164
 /// A builder for [`CreateVpcEndpointOutput`](crate::operation::create_vpc_endpoint::CreateVpcEndpointOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateVpcEndpointOutputBuilder {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc_endpoint_connection_notification.rs

@@ -1,1 +40,46 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `CreateVpcEndpointConnectionNotification`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateVpcEndpointConnectionNotification;
 impl CreateVpcEndpointConnectionNotification {
     /// Creates a new `CreateVpcEndpointConnectionNotification`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationInput,
     ) -> ::std::result::Result<
         crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -124,130 +186,193 @@

↥ Expand context

         });
-131
         ::std::option::Option::Some(cfg.freeze())
-133
+    }
-134
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CreateVpcEndpointConnectionNotification")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateVpcEndpointConnectionNotificationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationError,
             >::new());
-152
         ::std::borrow::Cow::Owned(rcb)
-154
+    }
-155
+}
-156
 #[derive(Debug)]
 struct CreateVpcEndpointConnectionNotificationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateVpcEndpointConnectionNotificationResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_create_vpc_endpoint_connection_notification::de_create_vpc_endpoint_connection_notification_http_error(
                 status, headers, body,

↧ Expand context

-174
+            )
         } else {
             crate::protocol_serde::shape_create_vpc_endpoint_connection_notification::de_create_vpc_endpoint_connection_notification_http_response(
                 status, headers, body,
-178
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
-181
+    }
-182
+}
 #[derive(Debug)]
 struct CreateVpcEndpointConnectionNotificationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateVpcEndpointConnectionNotificationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationInput>()

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc_endpoint_connection_notification/_create_vpc_endpoint_connection_notification_input.rs

@@ -29,29 +246,249 @@

↥ Expand context

     pub fn vpc_endpoint_id(&self) -> ::std::option::Option<&str> {
         self.vpc_endpoint_id.as_deref()
-31
+    }
     /// <p>The ARN of the SNS topic for the notifications.</p>
     pub fn connection_notification_arn(&self) -> ::std::option::Option<&str> {
         self.connection_notification_arn.as_deref()
-35
+    }
     /// <p>The endpoint events for which to receive notifications. Valid values are <code>Accept</code>, <code>Connect</code>, <code>Delete</code>, and <code>Reject</code>.</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 `.connection_events.is_none()`.
     pub fn connection_events(&self) -> &[::std::string::String] {
         self.connection_events.as_deref().unwrap_or_default()
-41
+    }
     /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request. For more information, see <a href="https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html">How to ensure idempotency</a>.</p>
     pub fn client_token(&self) -> ::std::option::Option<&str> {
         self.client_token.as_deref()
-45
+    }
-46
+}
 static CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateVpcEndpointConnectionNotificationInput",

     "com.amazonaws.ec2.synthetic",
     "CreateVpcEndpointConnectionNotificationInput",
 );
 static CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointConnectionNotificationInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointConnectionNotificationInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_SERVICE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointConnectionNotificationInput$ServiceId",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointConnectionNotificationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "service_id",
     "ServiceId",
 ,
 );
 static CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_VPC_ENDPOINT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointConnectionNotificationInput$VpcEndpointId",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointConnectionNotificationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpc_endpoint_id",
     "VpcEndpointId",
 ,
 );
 static CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_CONNECTION_NOTIFICATION_ARN: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#CreateVpcEndpointConnectionNotificationInput$ConnectionNotificationArn",
             "com.amazonaws.ec2.synthetic",
             "CreateVpcEndpointConnectionNotificationInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "connection_notification_arn",
         "ConnectionNotificationArn",
 ,
     );
 static CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_CONNECTION_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointConnectionNotificationInput$ConnectionEvents",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointConnectionNotificationInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "connection_events",
     "ConnectionEvents",
 ,
 );
 static CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointConnectionNotificationInput$ClientToken",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointConnectionNotificationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
 );
 static CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_DRY_RUN,
         &CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_SERVICE_ID,
         &CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_VPC_ENDPOINT_ID,
         &CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_CONNECTION_NOTIFICATION_ARN,
         &CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_CONNECTION_EVENTS,
         &CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_CLIENT_TOKEN,
     ],
 );
 impl CreateVpcEndpointConnectionNotificationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_SCHEMA;
-128
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateVpcEndpointConnectionNotificationInput {
     #[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.dry_run {
             ser.write_boolean(&CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_DRY_RUN, *val)?;
-137
+        }
         if let Some(ref val) = self.service_id {
             ser.write_string(&CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_SERVICE_ID, val)?;
-140
+        }
         if let Some(ref val) = self.vpc_endpoint_id {
             ser.write_string(&CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_VPC_ENDPOINT_ID, val)?;
-143
+        }
         if let Some(ref val) = self.connection_notification_arn {
             ser.write_string(&CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_CONNECTION_NOTIFICATION_ARN, val)?;
-146
+        }
         if let Some(ref val) = self.connection_events {
             ser.write_list(
                 &CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_CONNECTION_EVENTS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-153
+                    }
                     Ok(())
                 },
             )?;
-157
+        }
         if let Some(ref val) = self.client_token {
             ser.write_string(&CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_MEMBER_CLIENT_TOKEN, val)?;
-160
+        }
         Ok(())
-162
+    }
-163
+}
 impl CreateVpcEndpointConnectionNotificationInput {
     /// 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(&CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEVPCENDPOINTCONNECTIONNOTIFICATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-182
+                }
                 Some(1) => {
                     builder.service_id = Some(deser.read_string(member)?);
-185
+                }
                 Some(2) => {
                     builder.vpc_endpoint_id = Some(deser.read_string(member)?);
-188
+                }
                 Some(3) => {
                     builder.connection_notification_arn = Some(deser.read_string(member)?);
-191
+                }
                 Some(4) => {
                     builder.connection_events = 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.connection_events = Some(deser.read_string_list(member)?);
-194
+                }
                 Some(5) => {
                     builder.client_token = Some(deser.read_string(member)?);
-197
+                }
                 _ => {}
-199
+            }
             Ok(())
         })?;
         builder.connection_notification_arn = builder.connection_notification_arn.or(Some(String::new()));
         builder.connection_events = builder.connection_events.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-207
+    }
-208
+}
 impl CreateVpcEndpointConnectionNotificationInput {
     /// 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 CreateVpcEndpointConnectionNotificationInput {
     /// Creates a new builder-style object to manufacture [`CreateVpcEndpointConnectionNotificationInput`](crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationInput).
     pub fn builder() -> crate::operation::create_vpc_endpoint_connection_notification::builders::CreateVpcEndpointConnectionNotificationInputBuilder {
         crate::operation::create_vpc_endpoint_connection_notification::builders::CreateVpcEndpointConnectionNotificationInputBuilder::default()
-224
+    }
-225
+}
-226
 /// A builder for [`CreateVpcEndpointConnectionNotificationInput`](crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CreateVpcEndpointConnectionNotificationInputBuilder {
     pub(crate) dry_run: ::std::option::Option<bool>,
     pub(crate) service_id: ::std::option::Option<::std::string::String>,
     pub(crate) vpc_endpoint_id: ::std::option::Option<::std::string::String>,
     pub(crate) connection_notification_arn: ::std::option::Option<::std::string::String>,
     pub(crate) connection_events: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) client_token: ::std::option::Option<::std::string::String>,
-237
+}
 impl CreateVpcEndpointConnectionNotificationInputBuilder {
     /// <p>Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is <code>DryRunOperation</code>. Otherwise, it is <code>UnauthorizedOperation</code>.</p>
     pub fn dry_run(mut self, input: bool) -> Self {
         self.dry_run = ::std::option::Option::Some(input);
         self
-243
+    }
     /// <p>Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is <code>DryRunOperation</code>. Otherwise, it is <code>UnauthorizedOperation</code>.</p>
     pub fn set_dry_run(mut self, input: ::std::option::Option<bool>) -> Self {
         self.dry_run = input;
         self
-248
+    }
     /// <p>Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is <code>DryRunOperation</code>. Otherwise, it is <code>UnauthorizedOperation</code>.</p>

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc_endpoint_connection_notification/_create_vpc_endpoint_connection_notification_output.rs

@@ -5,5 +121,169 @@

↥ Expand context

 pub struct CreateVpcEndpointConnectionNotificationOutput {
     /// <p>Information about the notification.</p>
     pub connection_notification: ::std::option::Option<crate::types::ConnectionNotification>,
     /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.</p>
     pub client_token: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-11
+}
 impl CreateVpcEndpointConnectionNotificationOutput {
     /// <p>Information about the notification.</p>
     pub fn connection_notification(&self) -> ::std::option::Option<&crate::types::ConnectionNotification> {
         self.connection_notification.as_ref()
-16
+    }
     /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.</p>
     pub fn client_token(&self) -> ::std::option::Option<&str> {
         self.client_token.as_deref()
-20
+    }
-21
+}
 static CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateVpcEndpointConnectionNotificationOutput",
     "com.amazonaws.ec2.synthetic",

     "CreateVpcEndpointConnectionNotificationOutput",
 );
 static CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_MEMBER_CONNECTION_NOTIFICATION: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#CreateVpcEndpointConnectionNotificationOutput$ConnectionNotification",
             "com.amazonaws.ec2.synthetic",
             "CreateVpcEndpointConnectionNotificationOutput",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "connection_notification",
         "ConnectionNotification",
 ,
-37
+    )
     .with_xml_name("connectionNotification");
 static CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointConnectionNotificationOutput$ClientToken",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointConnectionNotificationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
-48
+)
 .with_xml_name("clientToken");
 static CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_MEMBER_CONNECTION_NOTIFICATION,
         &CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_MEMBER_CLIENT_TOKEN,
         &CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl CreateVpcEndpointConnectionNotificationOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_SCHEMA;
-69
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateVpcEndpointConnectionNotificationOutput {
     #[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.connection_notification {
             ser.write_struct(&CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_MEMBER_CONNECTION_NOTIFICATION, val)?;
-78
+        }
         if let Some(ref val) = self.client_token {
             ser.write_string(&CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_MEMBER_CLIENT_TOKEN, val)?;
-81
+        }
         Ok(())
-83
+    }
-84
+}
 impl CreateVpcEndpointConnectionNotificationOutput {
     /// 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(&CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.connection_notification = Some(crate::types::ConnectionNotification::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder.client_token = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateVpcEndpointConnectionNotificationOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CREATEVPCENDPOINTCONNECTIONNOTIFICATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.connection_notification = Some(crate::types::ConnectionNotification::deserialize(deser)?);
-143
+                }
                 Some(1) => {
                     builder.client_token = Some(deser.read_string(member)?);
-146
+                }
                 _ => {}
-148
+            }
             Ok(())

↧ Expand context

         })?;
         Ok(builder.build())
-152
+    }
-153
+}
 impl ::aws_types::request_id::RequestId for CreateVpcEndpointConnectionNotificationOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-157
+    }
-158
+}
 impl CreateVpcEndpointConnectionNotificationOutput {
     /// Creates a new builder-style object to manufacture [`CreateVpcEndpointConnectionNotificationOutput`](crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationOutput).
     pub fn builder() -> crate::operation::create_vpc_endpoint_connection_notification::builders::CreateVpcEndpointConnectionNotificationOutputBuilder
-162
+    {
         crate::operation::create_vpc_endpoint_connection_notification::builders::CreateVpcEndpointConnectionNotificationOutputBuilder::default()
-164
+    }
-165
+}
-166
 /// A builder for [`CreateVpcEndpointConnectionNotificationOutput`](crate::operation::create_vpc_endpoint_connection_notification::CreateVpcEndpointConnectionNotificationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc_endpoint_service_configuration.rs

@@ -1,1 +40,46 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `CreateVpcEndpointServiceConfiguration`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateVpcEndpointServiceConfiguration;
 impl CreateVpcEndpointServiceConfiguration {
     /// Creates a new `CreateVpcEndpointServiceConfiguration`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::create_vpc_endpoint_service_configuration::CreateVpcEndpointServiceConfigurationInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::create_vpc_endpoint_service_configuration::CreateVpcEndpointServiceConfigurationOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::create_vpc_endpoint_service_configuration::CreateVpcEndpointServiceConfigurationInput,
     ) -> ::std::result::Result<
         crate::operation::create_vpc_endpoint_service_configuration::CreateVpcEndpointServiceConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::create_vpc_endpoint_service_configuration::CreateVpcEndpointServiceConfigurationError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::create_vpc_endpoint_service_configuration::CreateVpcEndpointServiceConfigurationError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::create_vpc_endpoint_service_configuration::CreateVpcEndpointServiceConfigurationOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -124,130 +186,193 @@

↥ Expand context

         });
-131
         ::std::option::Option::Some(cfg.freeze())
-133
+    }
-134
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CreateVpcEndpointServiceConfiguration")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateVpcEndpointServiceConfigurationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_vpc_endpoint_service_configuration::CreateVpcEndpointServiceConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_vpc_endpoint_service_configuration::CreateVpcEndpointServiceConfigurationError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::create_vpc_endpoint_service_configuration::CreateVpcEndpointServiceConfigurationError,
             >::new());
-152
         ::std::borrow::Cow::Owned(rcb)
-154
+    }
-155
+}
-156
 #[derive(Debug)]
 struct CreateVpcEndpointServiceConfigurationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateVpcEndpointServiceConfigurationResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_create_vpc_endpoint_service_configuration::de_create_vpc_endpoint_service_configuration_http_error(
                 status, headers, body,

↧ Expand context

-174
+            )
         } else {
             crate::protocol_serde::shape_create_vpc_endpoint_service_configuration::de_create_vpc_endpoint_service_configuration_http_response(
                 status, headers, body,
-178
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
-181
+    }
-182
+}
 #[derive(Debug)]
 struct CreateVpcEndpointServiceConfigurationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateVpcEndpointServiceConfigurationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::create_vpc_endpoint_service_configuration::CreateVpcEndpointServiceConfigurationInput>()

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_vpc_endpoint_service_configuration/_create_vpc_endpoint_service_configuration_input.rs

@@ -55,55 +202,202 @@

↥ Expand context

-55
+    }
     /// <p>The Regions from which service consumers can access the service.</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 `.supported_regions.is_none()`.
     pub fn supported_regions(&self) -> &[::std::string::String] {
         self.supported_regions.as_deref().unwrap_or_default()
-61
+    }
     /// <p>Unique, case-sensitive identifier that you provide to ensure the idempotency of the request. For more information, see <a href="https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html">How to ensure idempotency</a>.</p>
     pub fn client_token(&self) -> ::std::option::Option<&str> {
         self.client_token.as_deref()
-65
+    }
     /// <p>The tags to associate with the service.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tag_specifications.is_none()`.
     pub fn tag_specifications(&self) -> &[crate::types::TagSpecification] {
         self.tag_specifications.as_deref().unwrap_or_default()
-71
+    }
-72
+}
 static CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateVpcEndpointServiceConfigurationInput",

     "com.amazonaws.ec2.synthetic",
     "CreateVpcEndpointServiceConfigurationInput",
 );
 static CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointServiceConfigurationInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointServiceConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_ACCEPTANCE_REQUIRED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointServiceConfigurationInput$AcceptanceRequired",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointServiceConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "acceptance_required",
     "AcceptanceRequired",
 ,
 );
 static CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_PRIVATE_DNS_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointServiceConfigurationInput$PrivateDnsName",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointServiceConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "private_dns_name",
     "PrivateDnsName",
 ,
 );
 static CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_NETWORK_LOAD_BALANCER_ARNS: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#CreateVpcEndpointServiceConfigurationInput$NetworkLoadBalancerArns",
             "com.amazonaws.ec2.synthetic",
             "CreateVpcEndpointServiceConfigurationInput",
         ),
         ::aws_smithy_schema::ShapeType::List,
         "network_load_balancer_arns",
         "NetworkLoadBalancerArns",
 ,
-118
+    )
     .with_xml_name("NetworkLoadBalancerArn");
 static CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_GATEWAY_LOAD_BALANCER_ARNS: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#CreateVpcEndpointServiceConfigurationInput$GatewayLoadBalancerArns",
             "com.amazonaws.ec2.synthetic",
             "CreateVpcEndpointServiceConfigurationInput",
         ),
         ::aws_smithy_schema::ShapeType::List,
         "gateway_load_balancer_arns",
         "GatewayLoadBalancerArns",
 ,
-130
+    )
     .with_xml_name("GatewayLoadBalancerArn");
 static CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_SUPPORTED_IP_ADDRESS_TYPES: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#CreateVpcEndpointServiceConfigurationInput$SupportedIpAddressTypes",
             "com.amazonaws.ec2.synthetic",
             "CreateVpcEndpointServiceConfigurationInput",
         ),
         ::aws_smithy_schema::ShapeType::List,
         "supported_ip_address_types",
         "SupportedIpAddressTypes",
 ,
-142
+    )
     .with_xml_name("SupportedIpAddressType");
 static CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_SUPPORTED_REGIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointServiceConfigurationInput$SupportedRegions",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointServiceConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "supported_regions",
     "SupportedRegions",
 ,
-153
+)
 .with_xml_name("SupportedRegion");
 static CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointServiceConfigurationInput$ClientToken",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointServiceConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
 );
 static CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateVpcEndpointServiceConfigurationInput$TagSpecifications",
         "com.amazonaws.ec2.synthetic",
         "CreateVpcEndpointServiceConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_specifications",
     "TagSpecifications",
 ,
-174
+)
 .with_xml_name("TagSpecification");
 static CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_DRY_RUN,
         &CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_ACCEPTANCE_REQUIRED,
         &CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_PRIVATE_DNS_NAME,

↧ Expand context

         &CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_NETWORK_LOAD_BALANCER_ARNS,
         &CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_GATEWAY_LOAD_BALANCER_ARNS,
         &CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_SUPPORTED_IP_ADDRESS_TYPES,
         &CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_SUPPORTED_REGIONS,
         &CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_CLIENT_TOKEN,
         &CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_TAG_SPECIFICATIONS,
     ],
 );
 impl CreateVpcEndpointServiceConfigurationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_SCHEMA;
-194
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateVpcEndpointServiceConfigurationInput {
     #[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.dry_run {
             ser.write_boolean(&CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_DRY_RUN, *val)?;

@@ -243,243 +402,370 @@

↥ Expand context

         if let Some(ref val) = self.supported_regions {
             ser.write_list(
                 &CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_SUPPORTED_REGIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-249
+                    }
                     Ok(())
                 },
             )?;
-253
+        }
         if let Some(ref val) = self.client_token {
             ser.write_string(&CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_CLIENT_TOKEN, val)?;
-256
+        }
         if let Some(ref val) = self.tag_specifications {
             ser.write_list(
                 &CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_MEMBER_TAG_SPECIFICATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;

-263
+                    }
                     Ok(())
                 },
             )?;
-267
+        }
         Ok(())
-269
+    }
-270
+}
 impl CreateVpcEndpointServiceConfigurationInput {
     /// 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(&CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATEVPCENDPOINTSERVICECONFIGURATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-289
+                }
                 Some(1) => {
                     builder.acceptance_required = Some(deser.read_boolean(member)?);
-292
+                }
                 Some(2) => {
                     builder.private_dns_name = Some(deser.read_string(member)?);
-295
+                }
                 Some(3) => {
                     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)?);
-298
+                }
                 Some(4) => {
                     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)?);
-301
+                }
                 Some(5) => {
                     builder.supported_ip_address_types = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.supported_ip_address_types = Some(deser.read_string_list(member)?);
-304
+                }
                 Some(6) => {
                     builder.supported_regions = 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.supported_regions = Some(deser.read_string_list(member)?);
-307
+                }
                 Some(7) => {
                     builder.client_token = Some(deser.read_string(member)?);
-310
+                }
                 Some(8) => {
                     builder.tag_specifications = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-320
+                }
                 _ => {}
-322
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-328
+    }
-329
+}
 impl CreateVpcEndpointServiceConfigurationInput {
     /// 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 CreateVpcEndpointServiceConfigurationInput {
     /// Creates a new builder-style object to manufacture [`CreateVpcEndpointServiceConfigurationInput`](crate::operation::create_vpc_endpoint_service_configuration::CreateVpcEndpointServiceConfigurationInput).
     pub fn builder() -> crate::operation::create_vpc_endpoint_service_configuration::builders::CreateVpcEndpointServiceConfigurationInputBuilder {
         crate::operation::create_vpc_endpoint_service_configuration::builders::CreateVpcEndpointServiceConfigurationInputBuilder::default()
-345
+    }
-346
+}
-347
 /// A builder for [`CreateVpcEndpointServiceConfigurationInput`](crate::operation::create_vpc_endpoint_service_configuration::CreateVpcEndpointServiceConfigurationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CreateVpcEndpointServiceConfigurationInputBuilder {
     pub(crate) dry_run: ::std::option::Option<bool>,
     pub(crate) acceptance_required: ::std::option::Option<bool>,
     pub(crate) private_dns_name: ::std::option::Option<::std::string::String>,
     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) supported_ip_address_types: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) supported_regions: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) client_token: ::std::option::Option<::std::string::String>,
     pub(crate) tag_specifications: ::std::option::Option<::std::vec::Vec<crate::types::TagSpecification>>,
-361
+}
 impl CreateVpcEndpointServiceConfigurationInputBuilder {
     /// <p>Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is <code>DryRunOperation</code>. Otherwise, it is <code>UnauthorizedOperation</code>.</p>
     pub fn dry_run(mut self, input: bool) -> Self {
         self.dry_run = ::std::option::Option::Some(input);
         self
-367
+    }
     /// <p>Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is <code>DryRunOperation</code>. Otherwise, it is <code>UnauthorizedOperation</code>.</p>
     pub fn set_dry_run(mut self, input: ::std::option::Option<bool>) -> Self {
         self.dry_run = input;

AWS SDK

Files changed: