AWS SDK

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

@@ -41,41 +171,171 @@

     pub fn image_id(&self) -> ::std::option::Option<&str> {
         self.image_id.as_deref()
-43
+    }
     /// <p>The Amazon S3 bucket for the destination image. The destination bucket must exist.</p>
     pub fn s3_export_location(&self) -> ::std::option::Option<&crate::types::ExportTaskS3LocationRequest> {
         self.s3_export_location.as_ref()
-47
+    }
     /// <p>The name of the role that grants VM Import/Export permission to export images to your Amazon S3 bucket. If this parameter is not specified, the default role is named 'vmimport'.</p>
     pub fn role_name(&self) -> ::std::option::Option<&str> {
         self.role_name.as_deref()
-51
+    }
     /// <p>The tags to apply to the export image task during creation.</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()
-57
+    }
-58
+}
 static EXPORTIMAGEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#ExportImageInput",

     "com.amazonaws.ec2.synthetic",
     "ExportImageInput",
 );
 static EXPORTIMAGEINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageInput$ClientToken",
         "com.amazonaws.ec2.synthetic",
         "ExportImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
 );
 static EXPORTIMAGEINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageInput$Description",
         "com.amazonaws.ec2.synthetic",
         "ExportImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "description",
     "Description",
 ,
 );
 static EXPORTIMAGEINPUT_MEMBER_DISK_IMAGE_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageInput$DiskImageFormat",
         "com.amazonaws.ec2.synthetic",
         "ExportImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "disk_image_format",
     "DiskImageFormat",
 ,
 );
 static EXPORTIMAGEINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "ExportImageInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static EXPORTIMAGEINPUT_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageInput$ImageId",
         "com.amazonaws.ec2.synthetic",
         "ExportImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "image_id",
     "ImageId",
 ,
 );
 static EXPORTIMAGEINPUT_MEMBER_S3_EXPORT_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageInput$S3ExportLocation",
         "com.amazonaws.ec2.synthetic",
         "ExportImageInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "s3_export_location",
     "S3ExportLocation",
 ,
 );
 static EXPORTIMAGEINPUT_MEMBER_ROLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageInput$RoleName",
         "com.amazonaws.ec2.synthetic",
         "ExportImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "role_name",
     "RoleName",
 ,
 );
 static EXPORTIMAGEINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageInput$TagSpecifications",
         "com.amazonaws.ec2.synthetic",
         "ExportImageInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_specifications",
     "TagSpecifications",
 ,
-143
+)
 .with_xml_name("TagSpecification");
 static EXPORTIMAGEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EXPORTIMAGEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &EXPORTIMAGEINPUT_MEMBER_CLIENT_TOKEN,
         &EXPORTIMAGEINPUT_MEMBER_DESCRIPTION,
         &EXPORTIMAGEINPUT_MEMBER_DISK_IMAGE_FORMAT,

↧ Expand context

         &EXPORTIMAGEINPUT_MEMBER_DRY_RUN,
         &EXPORTIMAGEINPUT_MEMBER_IMAGE_ID,
         &EXPORTIMAGEINPUT_MEMBER_S3_EXPORT_LOCATION,
         &EXPORTIMAGEINPUT_MEMBER_ROLE_NAME,
         &EXPORTIMAGEINPUT_MEMBER_TAG_SPECIFICATIONS,
     ],
 );
 impl ExportImageInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXPORTIMAGEINPUT_SCHEMA;
-162
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ExportImageInput {
     #[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.client_token {
             ser.write_string(&EXPORTIMAGEINPUT_MEMBER_CLIENT_TOKEN, val)?;
-171
+        }

@@ -176,176 +292,301 @@

↥ Expand context

             ser.write_string(&EXPORTIMAGEINPUT_MEMBER_DISK_IMAGE_FORMAT, val.as_str())?;
-177
+        }
         if let Some(ref val) = self.dry_run {
             ser.write_boolean(&EXPORTIMAGEINPUT_MEMBER_DRY_RUN, *val)?;
-180
+        }
         if let Some(ref val) = self.image_id {
             ser.write_string(&EXPORTIMAGEINPUT_MEMBER_IMAGE_ID, val)?;
-183
+        }
         if let Some(ref val) = self.s3_export_location {
             ser.write_struct(&EXPORTIMAGEINPUT_MEMBER_S3_EXPORT_LOCATION, val)?;
-186
+        }
         if let Some(ref val) = self.role_name {
             ser.write_string(&EXPORTIMAGEINPUT_MEMBER_ROLE_NAME, val)?;
-189
+        }
         if let Some(ref val) = self.tag_specifications {
             ser.write_list(
                 &EXPORTIMAGEINPUT_MEMBER_TAG_SPECIFICATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;

-196
+                    }
                     Ok(())
                 },
             )?;
-200
+        }
         Ok(())
-202
+    }
-203
+}
 impl ExportImageInput {
     /// 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(&EXPORTIMAGEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EXPORTIMAGEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.client_token = Some(deser.read_string(member)?);
-222
+                }
                 Some(1) => {
                     builder.description = Some(deser.read_string(member)?);
-225
+                }
                 Some(2) => {
                     builder.disk_image_format = Some(crate::types::DiskImageFormat::from(deser.read_string(member)?.as_str()));
-228
+                }
                 Some(3) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-231
+                }
                 Some(4) => {
                     builder.image_id = Some(deser.read_string(member)?);
-234
+                }
                 Some(5) => {
                     builder.s3_export_location = Some(crate::types::ExportTaskS3LocationRequest::deserialize(deser)?);
-237
+                }
                 Some(6) => {
                     builder.role_name = Some(deser.read_string(member)?);
-240
+                }
                 Some(7) => {
                     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
                     });
-250
+                }
                 _ => {}
-252
+            }
             Ok(())
         })?;
         builder.image_id = builder.image_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-259
+    }
-260
+}
 impl ExportImageInput {
     /// 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 ExportImageInput {
     /// Creates a new builder-style object to manufacture [`ExportImageInput`](crate::operation::export_image::ExportImageInput).
     pub fn builder() -> crate::operation::export_image::builders::ExportImageInputBuilder {
         crate::operation::export_image::builders::ExportImageInputBuilder::default()
-276
+    }
-277
+}
-278
 /// A builder for [`ExportImageInput`](crate::operation::export_image::ExportImageInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ExportImageInputBuilder {
     pub(crate) client_token: ::std::option::Option<::std::string::String>,
     pub(crate) description: ::std::option::Option<::std::string::String>,
     pub(crate) disk_image_format: ::std::option::Option<crate::types::DiskImageFormat>,
     pub(crate) dry_run: ::std::option::Option<bool>,
     pub(crate) image_id: ::std::option::Option<::std::string::String>,
     pub(crate) s3_export_location: ::std::option::Option<crate::types::ExportTaskS3LocationRequest>,
     pub(crate) role_name: ::std::option::Option<::std::string::String>,
     pub(crate) tag_specifications: ::std::option::Option<::std::vec::Vec<crate::types::TagSpecification>>,
-291
+}
 impl ExportImageInputBuilder {
     /// <p>Token to enable idempotency for export image requests.</p>
     pub fn client_token(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.client_token = ::std::option::Option::Some(input.into());
         self
-297
+    }
     /// <p>Token to enable idempotency for export image requests.</p>
     pub fn set_client_token(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.client_token = input;
         self

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

@@ -54,54 +337,413 @@

↥ Expand context

     pub fn s3_export_location(&self) -> ::std::option::Option<&crate::types::ExportTaskS3Location> {
         self.s3_export_location.as_ref()
-56
+    }
     /// <p>The status of the export image task. The possible values are <code>active</code>, <code>completed</code>, <code>deleting</code>, and <code>deleted</code>.</p>
     pub fn status(&self) -> ::std::option::Option<&str> {
         self.status.as_deref()
-60
+    }
     /// <p>The status message for the export image task.</p>
     pub fn status_message(&self) -> ::std::option::Option<&str> {
         self.status_message.as_deref()
-64
+    }
     /// <p>Any tags assigned to the export image task.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
     pub fn tags(&self) -> &[crate::types::Tag] {
         self.tags.as_deref().unwrap_or_default()
-70
+    }
-71
+}
 static EXPORTIMAGEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#ExportImageOutput",

     "com.amazonaws.ec2.synthetic",
     "ExportImageOutput",
 );
 static EXPORTIMAGEOUTPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageOutput$Description",
         "com.amazonaws.ec2.synthetic",
         "ExportImageOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "description",
     "Description",
 ,
-86
+)
 .with_xml_name("description");
 static EXPORTIMAGEOUTPUT_MEMBER_DISK_IMAGE_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageOutput$DiskImageFormat",
         "com.amazonaws.ec2.synthetic",
         "ExportImageOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "disk_image_format",
     "DiskImageFormat",
 ,
-97
+)
 .with_xml_name("diskImageFormat");
 static EXPORTIMAGEOUTPUT_MEMBER_EXPORT_IMAGE_TASK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageOutput$ExportImageTaskId",
         "com.amazonaws.ec2.synthetic",
         "ExportImageOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "export_image_task_id",
     "ExportImageTaskId",
 ,
-108
+)
 .with_xml_name("exportImageTaskId");
 static EXPORTIMAGEOUTPUT_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageOutput$ImageId",
         "com.amazonaws.ec2.synthetic",
         "ExportImageOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "image_id",
     "ImageId",
 ,
-119
+)
 .with_xml_name("imageId");
 static EXPORTIMAGEOUTPUT_MEMBER_ROLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageOutput$RoleName",
         "com.amazonaws.ec2.synthetic",
         "ExportImageOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "role_name",
     "RoleName",
 ,
-130
+)
 .with_xml_name("roleName");
 static EXPORTIMAGEOUTPUT_MEMBER_PROGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageOutput$Progress",
         "com.amazonaws.ec2.synthetic",
         "ExportImageOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "progress",
     "Progress",
 ,
-141
+)
 .with_xml_name("progress");
 static EXPORTIMAGEOUTPUT_MEMBER_S3_EXPORT_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageOutput$S3ExportLocation",
         "com.amazonaws.ec2.synthetic",
         "ExportImageOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "s3_export_location",
     "S3ExportLocation",
 ,
-152
+)
 .with_xml_name("s3ExportLocation");
 static EXPORTIMAGEOUTPUT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageOutput$Status",
         "com.amazonaws.ec2.synthetic",
         "ExportImageOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "status",
     "Status",
 ,
-163
+)
 .with_xml_name("status");
 static EXPORTIMAGEOUTPUT_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageOutput$StatusMessage",
         "com.amazonaws.ec2.synthetic",
         "ExportImageOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "status_message",
     "StatusMessage",
 ,
-174
+)
 .with_xml_name("statusMessage");
 static EXPORTIMAGEOUTPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportImageOutput$Tags",
         "com.amazonaws.ec2.synthetic",
         "ExportImageOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-185
+)
 .with_xml_name("tagSet");
 static EXPORTIMAGEOUTPUT_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 EXPORTIMAGEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EXPORTIMAGEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &EXPORTIMAGEOUTPUT_MEMBER_DESCRIPTION,
         &EXPORTIMAGEOUTPUT_MEMBER_DISK_IMAGE_FORMAT,
         &EXPORTIMAGEOUTPUT_MEMBER_EXPORT_IMAGE_TASK_ID,
         &EXPORTIMAGEOUTPUT_MEMBER_IMAGE_ID,
         &EXPORTIMAGEOUTPUT_MEMBER_ROLE_NAME,
         &EXPORTIMAGEOUTPUT_MEMBER_PROGRESS,
         &EXPORTIMAGEOUTPUT_MEMBER_S3_EXPORT_LOCATION,
         &EXPORTIMAGEOUTPUT_MEMBER_STATUS,
         &EXPORTIMAGEOUTPUT_MEMBER_STATUS_MESSAGE,
         &EXPORTIMAGEOUTPUT_MEMBER_TAGS,
         &EXPORTIMAGEOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ExportImageOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXPORTIMAGEOUTPUT_SCHEMA;
-214
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ExportImageOutput {
     #[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.description {
             ser.write_string(&EXPORTIMAGEOUTPUT_MEMBER_DESCRIPTION, val)?;
-223
+        }
         if let Some(ref val) = self.disk_image_format {
             ser.write_string(&EXPORTIMAGEOUTPUT_MEMBER_DISK_IMAGE_FORMAT, val.as_str())?;
-226
+        }
         if let Some(ref val) = self.export_image_task_id {
             ser.write_string(&EXPORTIMAGEOUTPUT_MEMBER_EXPORT_IMAGE_TASK_ID, val)?;
-229
+        }
         if let Some(ref val) = self.image_id {
             ser.write_string(&EXPORTIMAGEOUTPUT_MEMBER_IMAGE_ID, val)?;
-232
+        }
         if let Some(ref val) = self.role_name {
             ser.write_string(&EXPORTIMAGEOUTPUT_MEMBER_ROLE_NAME, val)?;
-235
+        }
         if let Some(ref val) = self.progress {
             ser.write_string(&EXPORTIMAGEOUTPUT_MEMBER_PROGRESS, val)?;
-238
+        }
         if let Some(ref val) = self.s3_export_location {
             ser.write_struct(&EXPORTIMAGEOUTPUT_MEMBER_S3_EXPORT_LOCATION, val)?;
-241
+        }
         if let Some(ref val) = self.status {
             ser.write_string(&EXPORTIMAGEOUTPUT_MEMBER_STATUS, val)?;
-244
+        }
         if let Some(ref val) = self.status_message {
             ser.write_string(&EXPORTIMAGEOUTPUT_MEMBER_STATUS_MESSAGE, val)?;
-247
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &EXPORTIMAGEOUTPUT_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-254
+                    }
                     Ok(())
                 },
             )?;
-258
+        }
         Ok(())
-260
+    }
-261
+}
 impl ExportImageOutput {
     /// 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(&EXPORTIMAGEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.description = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.disk_image_format = Some(crate::types::DiskImageFormat::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(2) => {
                     builder.export_image_task_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => {
                     builder.image_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(4) => {
                     builder.role_name = Some(deser.read_string(member)?);
-+
+                }
                 Some(5) => {
                     builder.progress = Some(deser.read_string(member)?);
-+
+                }
                 Some(6) => {
                     builder.s3_export_location = Some(crate::types::ExportTaskS3Location::deserialize(deser)?);
-+
+                }
                 Some(7) => {
                     builder.status = Some(deser.read_string(member)?);
-+
+                }
                 Some(8) => {
                     builder.status_message = Some(deser.read_string(member)?);
-+
+                }
                 Some(9) => {
                     builder.tags = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(10) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl ExportImageOutput {
     /// 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(&EXPORTIMAGEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EXPORTIMAGEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.description = Some(deser.read_string(member)?);
-351
+                }
                 Some(1) => {
                     builder.disk_image_format = Some(crate::types::DiskImageFormat::from(deser.read_string(member)?.as_str()));
-354
+                }
                 Some(2) => {
                     builder.export_image_task_id = Some(deser.read_string(member)?);
-357
+                }
                 Some(3) => {
                     builder.image_id = Some(deser.read_string(member)?);
-360
+                }
                 Some(4) => {
                     builder.role_name = Some(deser.read_string(member)?);
-363
+                }
                 Some(5) => {
                     builder.progress = Some(deser.read_string(member)?);
-366
+                }
                 Some(6) => {
                     builder.s3_export_location = Some(crate::types::ExportTaskS3Location::deserialize(deser)?);
-369
+                }
                 Some(7) => {
                     builder.status = Some(deser.read_string(member)?);
-372
+                }
                 Some(8) => {
                     builder.status_message = Some(deser.read_string(member)?);
-375
+                }
                 Some(9) => {
                     builder.tags = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Tag::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-385
+                }
                 _ => {}
-387
+            }
             Ok(())
         })?;
         Ok(builder.build())
-391
+    }
-392
+}
 impl ::aws_types::request_id::RequestId for ExportImageOutput {

↧ Expand context

     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-396
+    }
-397
+}
 impl ExportImageOutput {
     /// Creates a new builder-style object to manufacture [`ExportImageOutput`](crate::operation::export_image::ExportImageOutput).
     pub fn builder() -> crate::operation::export_image::builders::ExportImageOutputBuilder {
         crate::operation::export_image::builders::ExportImageOutputBuilder::default()
-402
+    }
-403
+}
-404
 /// A builder for [`ExportImageOutput`](crate::operation::export_image::ExportImageOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ExportImageOutputBuilder {
     pub(crate) description: ::std::option::Option<::std::string::String>,
     pub(crate) disk_image_format: ::std::option::Option<crate::types::DiskImageFormat>,
     pub(crate) export_image_task_id: ::std::option::Option<::std::string::String>,
     pub(crate) image_id: ::std::option::Option<::std::string::String>,
     pub(crate) role_name: ::std::option::Option<::std::string::String>,

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `ExportTransitGatewayRoutes`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ExportTransitGatewayRoutes;
 impl ExportTransitGatewayRoutes {
     /// Creates a new `ExportTransitGatewayRoutes`
     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::export_transit_gateway_routes::ExportTransitGatewayRoutesInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::export_transit_gateway_routes::ExportTransitGatewayRoutesOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::export_transit_gateway_routes::ExportTransitGatewayRoutesInput,
     ) -> ::std::result::Result<
         crate::operation::export_transit_gateway_routes::ExportTransitGatewayRoutesOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::export_transit_gateway_routes::ExportTransitGatewayRoutesError,
             ::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::export_transit_gateway_routes::ExportTransitGatewayRoutesError>()
                     .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::export_transit_gateway_routes::ExportTransitGatewayRoutesOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -118,124 +180,187 @@

↥ Expand context

         });
-125
         ::std::option::Option::Some(cfg.freeze())
-127
+    }
-128
     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("ExportTransitGatewayRoutes")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ExportTransitGatewayRoutesEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::export_transit_gateway_routes::ExportTransitGatewayRoutesError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::export_transit_gateway_routes::ExportTransitGatewayRoutesError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::export_transit_gateway_routes::ExportTransitGatewayRoutesError,
             >::new());
-146
         ::std::borrow::Cow::Owned(rcb)
-148
+    }
-149
+}
-150
 #[derive(Debug)]
 struct ExportTransitGatewayRoutesResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ExportTransitGatewayRoutesResponseDeserializer {
     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_export_transit_gateway_routes::de_export_transit_gateway_routes_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_export_transit_gateway_routes::de_export_transit_gateway_routes_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-171
+    }
-172
+}
 #[derive(Debug)]
 struct ExportTransitGatewayRoutesRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ExportTransitGatewayRoutesRequestSerializer {
     #[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::export_transit_gateway_routes::ExportTransitGatewayRoutesInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

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

@@ -57,57 +240,250 @@

↥ Expand context

     /// <p><code>transit-gateway-route-destination-cidr-block</code> - The CIDR range.</p></li>
     /// <li>
     /// <p><code>type</code> - The type of route (<code>propagated</code> | <code>static</code>).</p></li>
     /// </ul>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.filters.is_none()`.
     pub fn filters(&self) -> &[crate::types::Filter] {
         self.filters.as_deref().unwrap_or_default()
-65
+    }
     /// <p>The name of the S3 bucket.</p>
     pub fn s3_bucket(&self) -> ::std::option::Option<&str> {
         self.s3_bucket.as_deref()
-69
+    }
     /// <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
-73
+    }
-74
+}
 static EXPORTTRANSITGATEWAYROUTESINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#ExportTransitGatewayRoutesInput",

     "com.amazonaws.ec2.synthetic",
     "ExportTransitGatewayRoutesInput",
 );
 static EXPORTTRANSITGATEWAYROUTESINPUT_MEMBER_TRANSIT_GATEWAY_ROUTE_TABLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportTransitGatewayRoutesInput$TransitGatewayRouteTableId",
         "com.amazonaws.ec2.synthetic",
         "ExportTransitGatewayRoutesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "transit_gateway_route_table_id",
     "TransitGatewayRouteTableId",
 ,
 );
 static EXPORTTRANSITGATEWAYROUTESINPUT_MEMBER_FILTERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportTransitGatewayRoutesInput$Filters",
         "com.amazonaws.ec2.synthetic",
         "ExportTransitGatewayRoutesInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "filters",
     "Filters",
 ,
-99
+)
 .with_xml_name("Filter");
 static EXPORTTRANSITGATEWAYROUTESINPUT_MEMBER_S3_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportTransitGatewayRoutesInput$S3Bucket",
         "com.amazonaws.ec2.synthetic",
         "ExportTransitGatewayRoutesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "s3_bucket",
     "S3Bucket",
 ,
 );
 static EXPORTTRANSITGATEWAYROUTESINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportTransitGatewayRoutesInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "ExportTransitGatewayRoutesInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static EXPORTTRANSITGATEWAYROUTESINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EXPORTTRANSITGATEWAYROUTESINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &EXPORTTRANSITGATEWAYROUTESINPUT_MEMBER_TRANSIT_GATEWAY_ROUTE_TABLE_ID,
         &EXPORTTRANSITGATEWAYROUTESINPUT_MEMBER_FILTERS,
         &EXPORTTRANSITGATEWAYROUTESINPUT_MEMBER_S3_BUCKET,
         &EXPORTTRANSITGATEWAYROUTESINPUT_MEMBER_DRY_RUN,
     ],
 );
 impl ExportTransitGatewayRoutesInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXPORTTRANSITGATEWAYROUTESINPUT_SCHEMA;
-134
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ExportTransitGatewayRoutesInput {
     #[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.transit_gateway_route_table_id {
             ser.write_string(&EXPORTTRANSITGATEWAYROUTESINPUT_MEMBER_TRANSIT_GATEWAY_ROUTE_TABLE_ID, val)?;
-143
+        }
         if let Some(ref val) = self.filters {
             ser.write_list(
                 &EXPORTTRANSITGATEWAYROUTESINPUT_MEMBER_FILTERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Filter::SCHEMA, item)?;
-150
+                    }
                     Ok(())
                 },
             )?;
-154
+        }
         if let Some(ref val) = self.s3_bucket {
             ser.write_string(&EXPORTTRANSITGATEWAYROUTESINPUT_MEMBER_S3_BUCKET, val)?;
-157
+        }
         if let Some(ref val) = self.dry_run {
             ser.write_boolean(&EXPORTTRANSITGATEWAYROUTESINPUT_MEMBER_DRY_RUN, *val)?;
-160
+        }
         Ok(())
-162
+    }
-163
+}
 impl ExportTransitGatewayRoutesInput {
     /// 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(&EXPORTTRANSITGATEWAYROUTESINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EXPORTTRANSITGATEWAYROUTESINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.transit_gateway_route_table_id = Some(deser.read_string(member)?);
-182
+                }
                 Some(1) => {
                     builder.filters = 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::Filter::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Filter::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-192
+                }
                 Some(2) => {
                     builder.s3_bucket = Some(deser.read_string(member)?);
-195
+                }
                 Some(3) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-198
+                }
                 _ => {}
-200
+            }
             Ok(())
         })?;
         builder.transit_gateway_route_table_id = builder.transit_gateway_route_table_id.or(Some(String::new()));
         builder.s3_bucket = builder.s3_bucket.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-208
+    }
-209
+}
 impl ExportTransitGatewayRoutesInput {
     /// 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 ExportTransitGatewayRoutesInput {
     /// Creates a new builder-style object to manufacture [`ExportTransitGatewayRoutesInput`](crate::operation::export_transit_gateway_routes::ExportTransitGatewayRoutesInput).
     pub fn builder() -> crate::operation::export_transit_gateway_routes::builders::ExportTransitGatewayRoutesInputBuilder {
         crate::operation::export_transit_gateway_routes::builders::ExportTransitGatewayRoutesInputBuilder::default()
-225
+    }
-226
+}
-227
 /// A builder for [`ExportTransitGatewayRoutesInput`](crate::operation::export_transit_gateway_routes::ExportTransitGatewayRoutesInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ExportTransitGatewayRoutesInputBuilder {
     pub(crate) transit_gateway_route_table_id: ::std::option::Option<::std::string::String>,
     pub(crate) filters: ::std::option::Option<::std::vec::Vec<crate::types::Filter>>,
     pub(crate) s3_bucket: ::std::option::Option<::std::string::String>,
     pub(crate) dry_run: ::std::option::Option<bool>,
-236
+}
 impl ExportTransitGatewayRoutesInputBuilder {
     /// <p>The ID of the route table.</p>
     /// This field is required.
     pub fn transit_gateway_route_table_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.transit_gateway_route_table_id = ::std::option::Option::Some(input.into());
         self
-243
+    }
     /// <p>The ID of the route table.</p>
     pub fn set_transit_gateway_route_table_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.transit_gateway_route_table_id = input;
         self
-248
+    }
     /// <p>The ID of the route table.</p>
     pub fn get_transit_gateway_route_table_id(&self) -> &::std::option::Option<::std::string::String> {

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

@@ -1,1 +97,144 @@

↥ 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 ExportTransitGatewayRoutesOutput {
     /// <p>The URL of the exported file in Amazon S3. For example, s3://<i>bucket_name</i>/VPCTransitGateway/TransitGatewayRouteTables/<i>file_name</i>.</p>
     pub s3_location: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-9
+}
 impl ExportTransitGatewayRoutesOutput {
     /// <p>The URL of the exported file in Amazon S3. For example, s3://<i>bucket_name</i>/VPCTransitGateway/TransitGatewayRouteTables/<i>file_name</i>.</p>
     pub fn s3_location(&self) -> ::std::option::Option<&str> {
         self.s3_location.as_deref()
-14
+    }
-15
+}
 static EXPORTTRANSITGATEWAYROUTESOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#ExportTransitGatewayRoutesOutput",

     "com.amazonaws.ec2.synthetic",
     "ExportTransitGatewayRoutesOutput",
 );
 static EXPORTTRANSITGATEWAYROUTESOUTPUT_MEMBER_S3_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportTransitGatewayRoutesOutput$S3Location",
         "com.amazonaws.ec2.synthetic",
         "ExportTransitGatewayRoutesOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "s3_location",
     "S3Location",
 ,
-30
+)
 .with_xml_name("s3Location");
 static EXPORTTRANSITGATEWAYROUTESOUTPUT_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 EXPORTTRANSITGATEWAYROUTESOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EXPORTTRANSITGATEWAYROUTESOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&EXPORTTRANSITGATEWAYROUTESOUTPUT_MEMBER_S3_LOCATION],
     &[
         &EXPORTTRANSITGATEWAYROUTESOUTPUT_MEMBER_S3_LOCATION,
         &EXPORTTRANSITGATEWAYROUTESOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ExportTransitGatewayRoutesOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXPORTTRANSITGATEWAYROUTESOUTPUT_SCHEMA;
-50
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ExportTransitGatewayRoutesOutput {
     #[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.s3_location {
             ser.write_string(&EXPORTTRANSITGATEWAYROUTESOUTPUT_MEMBER_S3_LOCATION, val)?;
-59
+        }
         Ok(())
-61
+    }
-62
+}
 impl ExportTransitGatewayRoutesOutput {
     /// 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(&EXPORTTRANSITGATEWAYROUTESOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.s3_location = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl ExportTransitGatewayRoutesOutput {
     /// 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(&EXPORTTRANSITGATEWAYROUTESOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EXPORTTRANSITGATEWAYROUTESOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.s3_location = Some(deser.read_string(member)?);
-118
+                }
                 _ => {}
-120
+            }
             Ok(())
         })?;
         Ok(builder.build())
-124
+    }

↧ Expand context

-125
+}
 impl ::aws_types::request_id::RequestId for ExportTransitGatewayRoutesOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-129
+    }
-130
+}
 impl ExportTransitGatewayRoutesOutput {
     /// Creates a new builder-style object to manufacture [`ExportTransitGatewayRoutesOutput`](crate::operation::export_transit_gateway_routes::ExportTransitGatewayRoutesOutput).
     pub fn builder() -> crate::operation::export_transit_gateway_routes::builders::ExportTransitGatewayRoutesOutputBuilder {
         crate::operation::export_transit_gateway_routes::builders::ExportTransitGatewayRoutesOutputBuilder::default()
-135
+    }
-136
+}
-137
 /// A builder for [`ExportTransitGatewayRoutesOutput`](crate::operation::export_transit_gateway_routes::ExportTransitGatewayRoutesOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ExportTransitGatewayRoutesOutputBuilder {
     pub(crate) s3_location: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-144
+}

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/export_verified_access_instance_client_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 `ExportVerifiedAccessInstanceClientConfiguration`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ExportVerifiedAccessInstanceClientConfiguration;
 impl ExportVerifiedAccessInstanceClientConfiguration {
     /// Creates a new `ExportVerifiedAccessInstanceClientConfiguration`
     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::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationInput,
     ) -> ::std::result::Result<
         crate::operation::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationError,
             ::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::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationError>().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::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationOutput>().expect("correct output type"))
-40
+    }
-41
     pub(crate) async fn orchestrate_with_stop_point(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationInput,
         stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,
     ) -> ::std::result::Result<

@@ -121,127 +183,190 @@

↥ Expand context

-127
         ::std::option::Option::Some(cfg.freeze())
-129
+    }
-130
     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("ExportVerifiedAccessInstanceClientConfiguration")
                 .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
                 .with_interceptor(ExportVerifiedAccessInstanceClientConfigurationEndpointParamsInterceptor)
                 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                     crate::operation::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationError,
                 >::new())
                 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                     crate::operation::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationError,
                 >::new())
                 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                     crate::operation::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationError,
                 >::new());
-149
         ::std::borrow::Cow::Owned(rcb)
-151
+    }
-152
+}
-153
 #[derive(Debug)]
 struct ExportVerifiedAccessInstanceClientConfigurationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ExportVerifiedAccessInstanceClientConfigurationResponseDeserializer {
     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_export_verified_access_instance_client_configuration::de_export_verified_access_instance_client_configuration_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_export_verified_access_instance_client_configuration::de_export_verified_access_instance_client_configuration_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-174
+    }
-175
+}
 #[derive(Debug)]
 struct ExportVerifiedAccessInstanceClientConfigurationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ExportVerifiedAccessInstanceClientConfigurationRequestSerializer {
     #[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::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationInput>(
-187
+            )
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()

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

@@ -4,4 +137,149 @@

↥ Expand context

 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ExportVerifiedAccessInstanceClientConfigurationInput {
     /// <p>The ID of the Verified Access instance.</p>
     pub verified_access_instance_id: ::std::option::Option<::std::string::String>,
     /// <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 dry_run: ::std::option::Option<bool>,
-10
+}
 impl ExportVerifiedAccessInstanceClientConfigurationInput {
     /// <p>The ID of the Verified Access instance.</p>
     pub fn verified_access_instance_id(&self) -> ::std::option::Option<&str> {
         self.verified_access_instance_id.as_deref()
-15
+    }
     /// <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
-19
+    }
-20
+}
 static EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#ExportVerifiedAccessInstanceClientConfigurationInput",
     "com.amazonaws.ec2.synthetic",

     "ExportVerifiedAccessInstanceClientConfigurationInput",
 );
 static EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONINPUT_MEMBER_VERIFIED_ACCESS_INSTANCE_ID: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#ExportVerifiedAccessInstanceClientConfigurationInput$VerifiedAccessInstanceId",
             "com.amazonaws.ec2.synthetic",
             "ExportVerifiedAccessInstanceClientConfigurationInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "verified_access_instance_id",
         "VerifiedAccessInstanceId",
 ,
     );
 static EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportVerifiedAccessInstanceClientConfigurationInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "ExportVerifiedAccessInstanceClientConfigurationInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONINPUT_MEMBER_VERIFIED_ACCESS_INSTANCE_ID,
         &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONINPUT_MEMBER_DRY_RUN,
     ],
 );
 impl ExportVerifiedAccessInstanceClientConfigurationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONINPUT_SCHEMA;
-58
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ExportVerifiedAccessInstanceClientConfigurationInput {
     #[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.verified_access_instance_id {
             ser.write_string(
                 &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONINPUT_MEMBER_VERIFIED_ACCESS_INSTANCE_ID,
                 val,
             )?;
-70
+        }
         if let Some(ref val) = self.dry_run {
             ser.write_boolean(&EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONINPUT_MEMBER_DRY_RUN, *val)?;
-73
+        }
         Ok(())
-75
+    }
-76
+}
 impl ExportVerifiedAccessInstanceClientConfigurationInput {
     /// 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(&EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.verified_access_instance_id = Some(deser.read_string(member)?);
-95
+                }
                 Some(1) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-98
+                }
                 _ => {}
-100
+            }
             Ok(())
         })?;
         builder.verified_access_instance_id = builder.verified_access_instance_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-107
+    }
-108
+}
 impl ExportVerifiedAccessInstanceClientConfigurationInput {
     /// 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 ExportVerifiedAccessInstanceClientConfigurationInput {
     /// Creates a new builder-style object to manufacture [`ExportVerifiedAccessInstanceClientConfigurationInput`](crate::operation::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationInput).
     pub fn builder(
     ) -> crate::operation::export_verified_access_instance_client_configuration::builders::ExportVerifiedAccessInstanceClientConfigurationInputBuilder
-124
+    {
         crate::operation::export_verified_access_instance_client_configuration::builders::ExportVerifiedAccessInstanceClientConfigurationInputBuilder::default()
-126
+    }
-127
+}
-128
 /// A builder for [`ExportVerifiedAccessInstanceClientConfigurationInput`](crate::operation::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationInput).

↧ Expand context

 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ExportVerifiedAccessInstanceClientConfigurationInputBuilder {
     pub(crate) verified_access_instance_id: ::std::option::Option<::std::string::String>,
     pub(crate) dry_run: ::std::option::Option<bool>,
-135
+}
 impl ExportVerifiedAccessInstanceClientConfigurationInputBuilder {
     /// <p>The ID of the Verified Access instance.</p>
     /// This field is required.
     pub fn verified_access_instance_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.verified_access_instance_id = ::std::option::Option::Some(input.into());
         self
-142
+    }
     /// <p>The ID of the Verified Access instance.</p>
     pub fn set_verified_access_instance_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.verified_access_instance_id = input;
         self
-147
+    }
     /// <p>The ID of the Verified Access instance.</p>
     pub fn get_verified_access_instance_id(&self) -> &::std::option::Option<::std::string::String> {

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

@@ -32,32 +270,341 @@

↥ Expand context

-32
+    }
     /// <p>The device trust providers.</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 `.device_trust_providers.is_none()`.
     pub fn device_trust_providers(&self) -> &[crate::types::DeviceTrustProviderType] {
         self.device_trust_providers.as_deref().unwrap_or_default()
-38
+    }
     /// <p>The user identity trust provider.</p>
     pub fn user_trust_provider(&self) -> ::std::option::Option<&crate::types::VerifiedAccessInstanceUserTrustProviderClientConfiguration> {
         self.user_trust_provider.as_ref()
-42
+    }
     /// <p>The Open VPN configuration.</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 `.open_vpn_configurations.is_none()`.
     pub fn open_vpn_configurations(&self) -> &[crate::types::VerifiedAccessInstanceOpenVpnClientConfiguration] {
         self.open_vpn_configurations.as_deref().unwrap_or_default()
-48
+    }
-49
+}
 static EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#ExportVerifiedAccessInstanceClientConfigurationOutput",

     "com.amazonaws.ec2.synthetic",
     "ExportVerifiedAccessInstanceClientConfigurationOutput",
 );
 static EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportVerifiedAccessInstanceClientConfigurationOutput$Version",
         "com.amazonaws.ec2.synthetic",
         "ExportVerifiedAccessInstanceClientConfigurationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "version",
     "Version",
 ,
-64
+)
 .with_xml_name("version");
 static EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_VERIFIED_ACCESS_INSTANCE_ID: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#ExportVerifiedAccessInstanceClientConfigurationOutput$VerifiedAccessInstanceId",
             "com.amazonaws.ec2.synthetic",
             "ExportVerifiedAccessInstanceClientConfigurationOutput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "verified_access_instance_id",
         "VerifiedAccessInstanceId",
 ,
-76
+    )
     .with_xml_name("verifiedAccessInstanceId");
 static EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#ExportVerifiedAccessInstanceClientConfigurationOutput$Region",
         "com.amazonaws.ec2.synthetic",
         "ExportVerifiedAccessInstanceClientConfigurationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "region",
     "Region",
 ,
-87
+)
 .with_xml_name("region");
 static EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_DEVICE_TRUST_PROVIDERS: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#ExportVerifiedAccessInstanceClientConfigurationOutput$DeviceTrustProviders",
             "com.amazonaws.ec2.synthetic",
             "ExportVerifiedAccessInstanceClientConfigurationOutput",
         ),
         ::aws_smithy_schema::ShapeType::List,
         "device_trust_providers",
         "DeviceTrustProviders",
 ,
-99
+    )
     .with_xml_name("deviceTrustProviderSet");
 static EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_USER_TRUST_PROVIDER: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#ExportVerifiedAccessInstanceClientConfigurationOutput$UserTrustProvider",
             "com.amazonaws.ec2.synthetic",
             "ExportVerifiedAccessInstanceClientConfigurationOutput",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "user_trust_provider",
         "UserTrustProvider",
 ,
-111
+    )
     .with_xml_name("userTrustProvider");
 static EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_OPEN_VPN_CONFIGURATIONS: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#ExportVerifiedAccessInstanceClientConfigurationOutput$OpenVpnConfigurations",
             "com.amazonaws.ec2.synthetic",
             "ExportVerifiedAccessInstanceClientConfigurationOutput",
         ),
         ::aws_smithy_schema::ShapeType::List,
         "open_vpn_configurations",
         "OpenVpnConfigurations",
 ,
-123
+    )
     .with_xml_name("openVpnConfigurationSet");
 static EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_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 EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_VERSION,
         &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_VERIFIED_ACCESS_INSTANCE_ID,
         &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_REGION,
         &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_DEVICE_TRUST_PROVIDERS,
         &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_USER_TRUST_PROVIDER,
         &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_OPEN_VPN_CONFIGURATIONS,
         &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ExportVerifiedAccessInstanceClientConfigurationOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_SCHEMA;
-149
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ExportVerifiedAccessInstanceClientConfigurationOutput {
     #[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.version {
             ser.write_string(&EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_VERSION, val)?;
-158
+        }
         if let Some(ref val) = self.verified_access_instance_id {
             ser.write_string(
                 &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_VERIFIED_ACCESS_INSTANCE_ID,
                 val,
             )?;
-164
+        }
         if let Some(ref val) = self.region {
             ser.write_string(&EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_REGION, val)?;
-167
+        }
         if let Some(ref val) = self.device_trust_providers {
             ser.write_list(
                 &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_DEVICE_TRUST_PROVIDERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
-174
+                    }
                     Ok(())
                 },
             )?;
-178
+        }
         if let Some(ref val) = self.user_trust_provider {
             ser.write_struct(&EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_USER_TRUST_PROVIDER, val)?;
-181
+        }
         if let Some(ref val) = self.open_vpn_configurations {
             ser.write_list(
                 &EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_MEMBER_OPEN_VPN_CONFIGURATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::VerifiedAccessInstanceOpenVpnClientConfiguration::SCHEMA, item)?;
-188
+                    }
                     Ok(())
                 },
             )?;
-192
+        }
         Ok(())
-194
+    }
-195
+}
 impl ExportVerifiedAccessInstanceClientConfigurationOutput {
     /// 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(&EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.version = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.verified_access_instance_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder.region = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => {
                     builder.device_trust_providers = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::DeviceTrustProviderType::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(4) => {
                     builder.user_trust_provider = Some(crate::types::VerifiedAccessInstanceUserTrustProviderClientConfiguration::deserialize(
                         deser,
                     )?);
-+
+                }
                 Some(5) => {
                     builder.open_vpn_configurations = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::VerifiedAccessInstanceOpenVpnClientConfiguration::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(6) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl ExportVerifiedAccessInstanceClientConfigurationOutput {
     /// 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(&EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EXPORTVERIFIEDACCESSINSTANCECLIENTCONFIGURATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.version = Some(deser.read_string(member)?);
-282
+                }
                 Some(1) => {
                     builder.verified_access_instance_id = Some(deser.read_string(member)?);
-285
+                }
                 Some(2) => {
                     builder.region = Some(deser.read_string(member)?);
-288
+                }
                 Some(3) => {
                     builder.device_trust_providers = 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::DeviceTrustProviderType::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::DeviceTrustProviderType::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-298
+                }
                 Some(4) => {
                     builder.user_trust_provider = Some(crate::types::VerifiedAccessInstanceUserTrustProviderClientConfiguration::deserialize(
                         deser,
                     )?);
-303
+                }
                 Some(5) => {
                     builder.open_vpn_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::VerifiedAccessInstanceOpenVpnClientConfiguration::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::VerifiedAccessInstanceOpenVpnClientConfiguration::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-313
+                }
                 _ => {}
-315
+            }
             Ok(())
         })?;
         Ok(builder.build())
-319
+    }
-320
+}
 impl ::aws_types::request_id::RequestId for ExportVerifiedAccessInstanceClientConfigurationOutput {

↧ Expand context

     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-324
+    }
-325
+}
 impl ExportVerifiedAccessInstanceClientConfigurationOutput {
     /// Creates a new builder-style object to manufacture [`ExportVerifiedAccessInstanceClientConfigurationOutput`](crate::operation::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationOutput).
     pub fn builder(
     ) -> crate::operation::export_verified_access_instance_client_configuration::builders::ExportVerifiedAccessInstanceClientConfigurationOutputBuilder
-330
+    {
         crate::operation::export_verified_access_instance_client_configuration::builders::ExportVerifiedAccessInstanceClientConfigurationOutputBuilder::default()
-332
+    }
-333
+}
-334
 /// A builder for [`ExportVerifiedAccessInstanceClientConfigurationOutput`](crate::operation::export_verified_access_instance_client_configuration::ExportVerifiedAccessInstanceClientConfigurationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ExportVerifiedAccessInstanceClientConfigurationOutputBuilder {
     pub(crate) version: ::std::option::Option<::std::string::String>,
     pub(crate) verified_access_instance_id: ::std::option::Option<::std::string::String>,
     pub(crate) region: ::std::option::Option<::std::string::String>,

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `GetActiveVpnTunnelStatus`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetActiveVpnTunnelStatus;
 impl GetActiveVpnTunnelStatus {
     /// Creates a new `GetActiveVpnTunnelStatus`
     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::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusInput,
     ) -> ::std::result::Result<
         crate::operation::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusError,
             ::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::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusError>()
                     .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::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -118,124 +180,187 @@

↥ Expand context

         });
-125
         ::std::option::Option::Some(cfg.freeze())
-127
+    }
-128
     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("GetActiveVpnTunnelStatus")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetActiveVpnTunnelStatusEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusError,
             >::new());
-146
         ::std::borrow::Cow::Owned(rcb)
-148
+    }
-149
+}
-150
 #[derive(Debug)]
 struct GetActiveVpnTunnelStatusResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetActiveVpnTunnelStatusResponseDeserializer {
     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_get_active_vpn_tunnel_status::de_get_active_vpn_tunnel_status_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_get_active_vpn_tunnel_status::de_get_active_vpn_tunnel_status_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-171
+    }
-172
+}
 #[derive(Debug)]
 struct GetActiveVpnTunnelStatusRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetActiveVpnTunnelStatusRequestSerializer {
     #[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::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

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

@@ -9,9 +156,169 @@

↥ Expand context

     pub vpn_tunnel_outside_ip_address: ::std::option::Option<::std::string::String>,
     /// <p>Checks whether you have the required permissions for the action, without actually making the request.</p>
     pub dry_run: ::std::option::Option<bool>,
-12
+}
 impl GetActiveVpnTunnelStatusInput {
     /// <p>The ID of the VPN connection for which to retrieve the active tunnel status.</p>
     pub fn vpn_connection_id(&self) -> ::std::option::Option<&str> {
         self.vpn_connection_id.as_deref()
-17
+    }
     /// <p>The external IP address of the VPN tunnel for which to retrieve the active status.</p>
     pub fn vpn_tunnel_outside_ip_address(&self) -> ::std::option::Option<&str> {
         self.vpn_tunnel_outside_ip_address.as_deref()
-21
+    }
     /// <p>Checks whether you have the required permissions for the action, without actually making the request.</p>
     pub fn dry_run(&self) -> ::std::option::Option<bool> {
         self.dry_run
-25
+    }
-26
+}
 static GETACTIVEVPNTUNNELSTATUSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#GetActiveVpnTunnelStatusInput",

     "com.amazonaws.ec2.synthetic",
     "GetActiveVpnTunnelStatusInput",
 );
 static GETACTIVEVPNTUNNELSTATUSINPUT_MEMBER_VPN_CONNECTION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#GetActiveVpnTunnelStatusInput$VpnConnectionId",
         "com.amazonaws.ec2.synthetic",
         "GetActiveVpnTunnelStatusInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpn_connection_id",
     "VpnConnectionId",
 ,
 );
 static GETACTIVEVPNTUNNELSTATUSINPUT_MEMBER_VPN_TUNNEL_OUTSIDE_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#GetActiveVpnTunnelStatusInput$VpnTunnelOutsideIpAddress",
         "com.amazonaws.ec2.synthetic",
         "GetActiveVpnTunnelStatusInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vpn_tunnel_outside_ip_address",
     "VpnTunnelOutsideIpAddress",
 ,
 );
 static GETACTIVEVPNTUNNELSTATUSINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#GetActiveVpnTunnelStatusInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "GetActiveVpnTunnelStatusInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static GETACTIVEVPNTUNNELSTATUSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETACTIVEVPNTUNNELSTATUSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &GETACTIVEVPNTUNNELSTATUSINPUT_MEMBER_VPN_CONNECTION_ID,
         &GETACTIVEVPNTUNNELSTATUSINPUT_MEMBER_VPN_TUNNEL_OUTSIDE_IP_ADDRESS,
         &GETACTIVEVPNTUNNELSTATUSINPUT_MEMBER_DRY_RUN,
     ],
 );
 impl GetActiveVpnTunnelStatusInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETACTIVEVPNTUNNELSTATUSINPUT_SCHEMA;
-74
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetActiveVpnTunnelStatusInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.vpn_connection_id {
             ser.write_string(&GETACTIVEVPNTUNNELSTATUSINPUT_MEMBER_VPN_CONNECTION_ID, val)?;
-83
+        }
         if let Some(ref val) = self.vpn_tunnel_outside_ip_address {
             ser.write_string(&GETACTIVEVPNTUNNELSTATUSINPUT_MEMBER_VPN_TUNNEL_OUTSIDE_IP_ADDRESS, val)?;
-86
+        }
         if let Some(ref val) = self.dry_run {
             ser.write_boolean(&GETACTIVEVPNTUNNELSTATUSINPUT_MEMBER_DRY_RUN, *val)?;
-89
+        }
         Ok(())
-91
+    }
-92
+}
 impl GetActiveVpnTunnelStatusInput {
     /// 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(&GETACTIVEVPNTUNNELSTATUSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETACTIVEVPNTUNNELSTATUSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.vpn_connection_id = Some(deser.read_string(member)?);
-111
+                }
                 Some(1) => {
                     builder.vpn_tunnel_outside_ip_address = Some(deser.read_string(member)?);
-114
+                }
                 Some(2) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-117
+                }
                 _ => {}
-119
+            }
             Ok(())
         })?;
         builder.vpn_connection_id = builder.vpn_connection_id.or(Some(String::new()));
         builder.vpn_tunnel_outside_ip_address = builder.vpn_tunnel_outside_ip_address.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-127
+    }
-128
+}
 impl GetActiveVpnTunnelStatusInput {
     /// 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 GetActiveVpnTunnelStatusInput {
     /// Creates a new builder-style object to manufacture [`GetActiveVpnTunnelStatusInput`](crate::operation::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusInput).
     pub fn builder() -> crate::operation::get_active_vpn_tunnel_status::builders::GetActiveVpnTunnelStatusInputBuilder {
         crate::operation::get_active_vpn_tunnel_status::builders::GetActiveVpnTunnelStatusInputBuilder::default()
-144
+    }
-145
+}
-146
 /// A builder for [`GetActiveVpnTunnelStatusInput`](crate::operation::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GetActiveVpnTunnelStatusInputBuilder {
     pub(crate) vpn_connection_id: ::std::option::Option<::std::string::String>,
     pub(crate) vpn_tunnel_outside_ip_address: ::std::option::Option<::std::string::String>,
     pub(crate) dry_run: ::std::option::Option<bool>,
-154
+}
 impl GetActiveVpnTunnelStatusInputBuilder {
     /// <p>The ID of the VPN connection for which to retrieve the active tunnel status.</p>
     /// This field is required.
     pub fn vpn_connection_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.vpn_connection_id = ::std::option::Option::Some(input.into());
         self
-161
+    }
     /// <p>The ID of the VPN connection for which to retrieve the active tunnel status.</p>
     pub fn set_vpn_connection_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.vpn_connection_id = input;
         self
-166
+    }
     /// <p>The ID of the VPN connection for which to retrieve the active tunnel status.</p>
     pub fn get_vpn_connection_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.vpn_connection_id

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

@@ -1,1 +97,144 @@

↥ 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 GetActiveVpnTunnelStatusOutput {
     /// <p>Information about the current security configuration of the VPN tunnel.</p>
     pub active_vpn_tunnel_status: ::std::option::Option<crate::types::ActiveVpnTunnelStatus>,
     _request_id: Option<String>,
-9
+}
 impl GetActiveVpnTunnelStatusOutput {
     /// <p>Information about the current security configuration of the VPN tunnel.</p>
     pub fn active_vpn_tunnel_status(&self) -> ::std::option::Option<&crate::types::ActiveVpnTunnelStatus> {
         self.active_vpn_tunnel_status.as_ref()
-14
+    }
-15
+}
 static GETACTIVEVPNTUNNELSTATUSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#GetActiveVpnTunnelStatusOutput",

     "com.amazonaws.ec2.synthetic",
     "GetActiveVpnTunnelStatusOutput",
 );
 static GETACTIVEVPNTUNNELSTATUSOUTPUT_MEMBER_ACTIVE_VPN_TUNNEL_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#GetActiveVpnTunnelStatusOutput$ActiveVpnTunnelStatus",
         "com.amazonaws.ec2.synthetic",
         "GetActiveVpnTunnelStatusOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "active_vpn_tunnel_status",
     "ActiveVpnTunnelStatus",
 ,
-30
+)
 .with_xml_name("activeVpnTunnelStatus");
 static GETACTIVEVPNTUNNELSTATUSOUTPUT_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 GETACTIVEVPNTUNNELSTATUSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETACTIVEVPNTUNNELSTATUSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GETACTIVEVPNTUNNELSTATUSOUTPUT_MEMBER_ACTIVE_VPN_TUNNEL_STATUS],
     &[
         &GETACTIVEVPNTUNNELSTATUSOUTPUT_MEMBER_ACTIVE_VPN_TUNNEL_STATUS,
         &GETACTIVEVPNTUNNELSTATUSOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl GetActiveVpnTunnelStatusOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETACTIVEVPNTUNNELSTATUSOUTPUT_SCHEMA;
-50
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetActiveVpnTunnelStatusOutput {
     #[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.active_vpn_tunnel_status {
             ser.write_struct(&GETACTIVEVPNTUNNELSTATUSOUTPUT_MEMBER_ACTIVE_VPN_TUNNEL_STATUS, val)?;
-59
+        }
         Ok(())
-61
+    }
-62
+}
 impl GetActiveVpnTunnelStatusOutput {
     /// 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(&GETACTIVEVPNTUNNELSTATUSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETACTIVEVPNTUNNELSTATUSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.active_vpn_tunnel_status = Some(crate::types::ActiveVpnTunnelStatus::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl GetActiveVpnTunnelStatusOutput {
     /// 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(&GETACTIVEVPNTUNNELSTATUSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.active_vpn_tunnel_status = Some(crate::types::ActiveVpnTunnelStatus::deserialize(deser)?);
-118
+                }
                 _ => {}
-120
+            }
             Ok(())
         })?;
         Ok(builder.build())
-124
+    }

↧ Expand context

-125
+}
 impl ::aws_types::request_id::RequestId for GetActiveVpnTunnelStatusOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-129
+    }
-130
+}
 impl GetActiveVpnTunnelStatusOutput {
     /// Creates a new builder-style object to manufacture [`GetActiveVpnTunnelStatusOutput`](crate::operation::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusOutput).
     pub fn builder() -> crate::operation::get_active_vpn_tunnel_status::builders::GetActiveVpnTunnelStatusOutputBuilder {
         crate::operation::get_active_vpn_tunnel_status::builders::GetActiveVpnTunnelStatusOutputBuilder::default()
-135
+    }
-136
+}
-137
 /// A builder for [`GetActiveVpnTunnelStatusOutput`](crate::operation::get_active_vpn_tunnel_status::GetActiveVpnTunnelStatusOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetActiveVpnTunnelStatusOutputBuilder {
     pub(crate) active_vpn_tunnel_status: ::std::option::Option<crate::types::ActiveVpnTunnelStatus>,
     _request_id: Option<String>,
-144
+}

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `GetAllowedImagesSettings`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetAllowedImagesSettings;
 impl GetAllowedImagesSettings {
     /// Creates a new `GetAllowedImagesSettings`
     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::get_allowed_images_settings::GetAllowedImagesSettingsInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::get_allowed_images_settings::GetAllowedImagesSettingsOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::get_allowed_images_settings::GetAllowedImagesSettingsInput,
     ) -> ::std::result::Result<
         crate::operation::get_allowed_images_settings::GetAllowedImagesSettingsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_allowed_images_settings::GetAllowedImagesSettingsError,
             ::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::get_allowed_images_settings::GetAllowedImagesSettingsError>()
                     .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::get_allowed_images_settings::GetAllowedImagesSettingsOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -118,124 +180,187 @@

↥ Expand context

         });
-125
         ::std::option::Option::Some(cfg.freeze())
-127
+    }
-128
     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("GetAllowedImagesSettings")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetAllowedImagesSettingsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_allowed_images_settings::GetAllowedImagesSettingsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_allowed_images_settings::GetAllowedImagesSettingsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::get_allowed_images_settings::GetAllowedImagesSettingsError,
             >::new());
-146
         ::std::borrow::Cow::Owned(rcb)
-148
+    }
-149
+}
-150
 #[derive(Debug)]
 struct GetAllowedImagesSettingsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetAllowedImagesSettingsResponseDeserializer {
     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_get_allowed_images_settings::de_get_allowed_images_settings_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_get_allowed_images_settings::de_get_allowed_images_settings_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-171
+    }
-172
+}
 #[derive(Debug)]
 struct GetAllowedImagesSettingsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetAllowedImagesSettingsRequestSerializer {
     #[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::get_allowed_images_settings::GetAllowedImagesSettingsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

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

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

↥ 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 GetAllowedImagesSettingsInput {
     /// <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 dry_run: ::std::option::Option<bool>,
-8
+}
 impl GetAllowedImagesSettingsInput {
     /// <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
-13
+    }
-14
+}
 static GETALLOWEDIMAGESSETTINGSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#GetAllowedImagesSettingsInput",

     "com.amazonaws.ec2.synthetic",
     "GetAllowedImagesSettingsInput",
 );
 static GETALLOWEDIMAGESSETTINGSINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#GetAllowedImagesSettingsInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "GetAllowedImagesSettingsInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static GETALLOWEDIMAGESSETTINGSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETALLOWEDIMAGESSETTINGSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GETALLOWEDIMAGESSETTINGSINPUT_MEMBER_DRY_RUN],
 );
 impl GetAllowedImagesSettingsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETALLOWEDIMAGESSETTINGSINPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetAllowedImagesSettingsInput {
     #[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(&GETALLOWEDIMAGESSETTINGSINPUT_MEMBER_DRY_RUN, *val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl GetAllowedImagesSettingsInput {
     /// 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(&GETALLOWEDIMAGESSETTINGSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETALLOWEDIMAGESSETTINGSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-77
+    }
-78
+}
 impl GetAllowedImagesSettingsInput {
     /// 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 GetAllowedImagesSettingsInput {
     /// Creates a new builder-style object to manufacture [`GetAllowedImagesSettingsInput`](crate::operation::get_allowed_images_settings::GetAllowedImagesSettingsInput).
     pub fn builder() -> crate::operation::get_allowed_images_settings::builders::GetAllowedImagesSettingsInputBuilder {
         crate::operation::get_allowed_images_settings::builders::GetAllowedImagesSettingsInputBuilder::default()
-94
+    }
-95
+}
-96
 /// A builder for [`GetAllowedImagesSettingsInput`](crate::operation::get_allowed_images_settings::GetAllowedImagesSettingsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GetAllowedImagesSettingsInputBuilder {
     pub(crate) dry_run: ::std::option::Option<bool>,
-102
+}
 impl GetAllowedImagesSettingsInputBuilder {
     /// <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
-108
+    }
     /// <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
-113
+    }
     /// <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> {
         &self.dry_run
-117
+    }
     /// Consumes the builder and constructs a [`GetAllowedImagesSettingsInput`](crate::operation::get_allowed_images_settings::GetAllowedImagesSettingsInput).
     pub fn build(

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

@@ -42,42 +196,251 @@

↥ Expand context

-42
+    }
     /// <p>The list of criteria for images that are discoverable and usable in the account in the specified Amazon Web Services Region.</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 `.image_criteria.is_none()`.
     pub fn image_criteria(&self) -> &[crate::types::ImageCriterion] {
         self.image_criteria.as_deref().unwrap_or_default()
-48
+    }
     /// <p>The entity that manages the Allowed AMIs settings. Possible values include:</p>
     /// <ul>
     /// <li>
     /// <p><code>account</code> - The Allowed AMIs settings is managed by the account.</p></li>
     /// <li>
     /// <p><code>declarative-policy</code> - The Allowed AMIs settings is managed by a declarative policy and can't be modified by the account.</p></li>
     /// </ul>
     pub fn managed_by(&self) -> ::std::option::Option<&crate::types::ManagedBy> {
         self.managed_by.as_ref()
-58
+    }
-59
+}
 static GETALLOWEDIMAGESSETTINGSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#GetAllowedImagesSettingsOutput",

     "com.amazonaws.ec2.synthetic",
     "GetAllowedImagesSettingsOutput",
 );
 static GETALLOWEDIMAGESSETTINGSOUTPUT_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#GetAllowedImagesSettingsOutput$State",
         "com.amazonaws.ec2.synthetic",
         "GetAllowedImagesSettingsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "state",
     "State",
 ,
-74
+)
 .with_xml_name("state");
 static GETALLOWEDIMAGESSETTINGSOUTPUT_MEMBER_IMAGE_CRITERIA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#GetAllowedImagesSettingsOutput$ImageCriteria",
         "com.amazonaws.ec2.synthetic",
         "GetAllowedImagesSettingsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "image_criteria",
     "ImageCriteria",
 ,
-85
+)
 .with_xml_name("imageCriterionSet");
 static GETALLOWEDIMAGESSETTINGSOUTPUT_MEMBER_MANAGED_BY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#GetAllowedImagesSettingsOutput$ManagedBy",
         "com.amazonaws.ec2.synthetic",
         "GetAllowedImagesSettingsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "managed_by",
     "ManagedBy",
 ,
-96
+)
 .with_xml_name("managedBy");
 static GETALLOWEDIMAGESSETTINGSOUTPUT_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 GETALLOWEDIMAGESSETTINGSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETALLOWEDIMAGESSETTINGSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &GETALLOWEDIMAGESSETTINGSOUTPUT_MEMBER_STATE,
         &GETALLOWEDIMAGESSETTINGSOUTPUT_MEMBER_IMAGE_CRITERIA,
         &GETALLOWEDIMAGESSETTINGSOUTPUT_MEMBER_MANAGED_BY,
         &GETALLOWEDIMAGESSETTINGSOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl GetAllowedImagesSettingsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETALLOWEDIMAGESSETTINGSOUTPUT_SCHEMA;
-118
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetAllowedImagesSettingsOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.state {
             ser.write_string(&GETALLOWEDIMAGESSETTINGSOUTPUT_MEMBER_STATE, val)?;
-127
+        }
         if let Some(ref val) = self.image_criteria {
             ser.write_list(
                 &GETALLOWEDIMAGESSETTINGSOUTPUT_MEMBER_IMAGE_CRITERIA,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::ImageCriterion::SCHEMA, item)?;
-134
+                    }
                     Ok(())
                 },
             )?;
-138
+        }
         if let Some(ref val) = self.managed_by {
             ser.write_string(&GETALLOWEDIMAGESSETTINGSOUTPUT_MEMBER_MANAGED_BY, val.as_str())?;
-141
+        }
         Ok(())
-143
+    }
-144
+}
 impl GetAllowedImagesSettingsOutput {
     /// 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(&GETALLOWEDIMAGESSETTINGSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETALLOWEDIMAGESSETTINGSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.state = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.image_criteria = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ImageCriterion::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(2) => {
                     builder.managed_by = Some(crate::types::ManagedBy::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(3) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl GetAllowedImagesSettingsOutput {
     /// 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(&GETALLOWEDIMAGESSETTINGSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.state = Some(deser.read_string(member)?);
-213
+                }
                 Some(1) => {
                     builder.image_criteria = 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::ImageCriterion::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ImageCriterion::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-223
+                }
                 Some(2) => {
                     builder.managed_by = Some(crate::types::ManagedBy::from(deser.read_string(member)?.as_str()));
-226
+                }
                 _ => {}
-228
+            }
             Ok(())
         })?;
         Ok(builder.build())

↧ Expand context

-232
+    }
-233
+}
 impl ::aws_types::request_id::RequestId for GetAllowedImagesSettingsOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-237
+    }
-238
+}
 impl GetAllowedImagesSettingsOutput {
     /// Creates a new builder-style object to manufacture [`GetAllowedImagesSettingsOutput`](crate::operation::get_allowed_images_settings::GetAllowedImagesSettingsOutput).
     pub fn builder() -> crate::operation::get_allowed_images_settings::builders::GetAllowedImagesSettingsOutputBuilder {
         crate::operation::get_allowed_images_settings::builders::GetAllowedImagesSettingsOutputBuilder::default()
-243
+    }
-244
+}
-245
 /// A builder for [`GetAllowedImagesSettingsOutput`](crate::operation::get_allowed_images_settings::GetAllowedImagesSettingsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetAllowedImagesSettingsOutputBuilder {
     pub(crate) state: ::std::option::Option<::std::string::String>,
     pub(crate) image_criteria: ::std::option::Option<::std::vec::Vec<crate::types::ImageCriterion>>,

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `GetAssociatedEnclaveCertificateIamRoles`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetAssociatedEnclaveCertificateIamRoles;
 impl GetAssociatedEnclaveCertificateIamRoles {
     /// Creates a new `GetAssociatedEnclaveCertificateIamRoles`
     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::get_associated_enclave_certificate_iam_roles::GetAssociatedEnclaveCertificateIamRolesInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::get_associated_enclave_certificate_iam_roles::GetAssociatedEnclaveCertificateIamRolesOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::get_associated_enclave_certificate_iam_roles::GetAssociatedEnclaveCertificateIamRolesInput,
     ) -> ::std::result::Result<
         crate::operation::get_associated_enclave_certificate_iam_roles::GetAssociatedEnclaveCertificateIamRolesOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_associated_enclave_certificate_iam_roles::GetAssociatedEnclaveCertificateIamRolesError,
             ::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::get_associated_enclave_certificate_iam_roles::GetAssociatedEnclaveCertificateIamRolesError>()
                     .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::get_associated_enclave_certificate_iam_roles::GetAssociatedEnclaveCertificateIamRolesOutput>()
                 .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("GetAssociatedEnclaveCertificateIamRoles")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetAssociatedEnclaveCertificateIamRolesEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_associated_enclave_certificate_iam_roles::GetAssociatedEnclaveCertificateIamRolesError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_associated_enclave_certificate_iam_roles::GetAssociatedEnclaveCertificateIamRolesError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::get_associated_enclave_certificate_iam_roles::GetAssociatedEnclaveCertificateIamRolesError,
             >::new());
-152
         ::std::borrow::Cow::Owned(rcb)
-154
+    }
-155
+}
-156
 #[derive(Debug)]
 struct GetAssociatedEnclaveCertificateIamRolesResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetAssociatedEnclaveCertificateIamRolesResponseDeserializer {
     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_get_associated_enclave_certificate_iam_roles::de_get_associated_enclave_certificate_iam_roles_http_error(
                 status, headers, body,

↧ Expand context

-174
+            )
         } else {
             crate::protocol_serde::shape_get_associated_enclave_certificate_iam_roles::de_get_associated_enclave_certificate_iam_roles_http_response(
                 status, headers, body,
-178
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
-181
+    }
-182
+}
 #[derive(Debug)]
 struct GetAssociatedEnclaveCertificateIamRolesRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetAssociatedEnclaveCertificateIamRolesRequestSerializer {
     #[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::get_associated_enclave_certificate_iam_roles::GetAssociatedEnclaveCertificateIamRolesInput>()

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

@@ -3,3 +133,145 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GetAssociatedEnclaveCertificateIamRolesInput {
     /// <p>The ARN of the ACM certificate for which to view the associated IAM roles, encryption keys, and Amazon S3 object information.</p>
     pub certificate_arn: ::std::option::Option<::std::string::String>,
     /// <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 dry_run: ::std::option::Option<bool>,
-10
+}
 impl GetAssociatedEnclaveCertificateIamRolesInput {
     /// <p>The ARN of the ACM certificate for which to view the associated IAM roles, encryption keys, and Amazon S3 object information.</p>
     pub fn certificate_arn(&self) -> ::std::option::Option<&str> {
         self.certificate_arn.as_deref()
-15
+    }
     /// <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
-19
+    }
-20
+}
 static GETASSOCIATEDENCLAVECERTIFICATEIAMROLESINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#GetAssociatedEnclaveCertificateIamRolesInput",

     "com.amazonaws.ec2.synthetic",
     "GetAssociatedEnclaveCertificateIamRolesInput",
 );
 static GETASSOCIATEDENCLAVECERTIFICATEIAMROLESINPUT_MEMBER_CERTIFICATE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#GetAssociatedEnclaveCertificateIamRolesInput$CertificateArn",
         "com.amazonaws.ec2.synthetic",
         "GetAssociatedEnclaveCertificateIamRolesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "certificate_arn",
     "CertificateArn",
 ,
 );
 static GETASSOCIATEDENCLAVECERTIFICATEIAMROLESINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#GetAssociatedEnclaveCertificateIamRolesInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "GetAssociatedEnclaveCertificateIamRolesInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static GETASSOCIATEDENCLAVECERTIFICATEIAMROLESINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETASSOCIATEDENCLAVECERTIFICATEIAMROLESINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &GETASSOCIATEDENCLAVECERTIFICATEIAMROLESINPUT_MEMBER_CERTIFICATE_ARN,
         &GETASSOCIATEDENCLAVECERTIFICATEIAMROLESINPUT_MEMBER_DRY_RUN,
     ],
 );
 impl GetAssociatedEnclaveCertificateIamRolesInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETASSOCIATEDENCLAVECERTIFICATEIAMROLESINPUT_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetAssociatedEnclaveCertificateIamRolesInput {
     #[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.certificate_arn {
             ser.write_string(&GETASSOCIATEDENCLAVECERTIFICATEIAMROLESINPUT_MEMBER_CERTIFICATE_ARN, val)?;
-66
+        }
         if let Some(ref val) = self.dry_run {
             ser.write_boolean(&GETASSOCIATEDENCLAVECERTIFICATEIAMROLESINPUT_MEMBER_DRY_RUN, *val)?;
-69
+        }
         Ok(())
-71
+    }
-72
+}
 impl GetAssociatedEnclaveCertificateIamRolesInput {
     /// 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(&GETASSOCIATEDENCLAVECERTIFICATEIAMROLESINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETASSOCIATEDENCLAVECERTIFICATEIAMROLESINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.certificate_arn = Some(deser.read_string(member)?);
-91
+                }
                 Some(1) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-94
+                }
                 _ => {}
-96
+            }
             Ok(())
         })?;
         builder.certificate_arn = builder.certificate_arn.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-103
+    }
-104
+}
 impl GetAssociatedEnclaveCertificateIamRolesInput {
     /// 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 GetAssociatedEnclaveCertificateIamRolesInput {
     /// Creates a new builder-style object to manufacture [`GetAssociatedEnclaveCertificateIamRolesInput`](crate::operation::get_associated_enclave_certificate_iam_roles::GetAssociatedEnclaveCertificateIamRolesInput).
     pub fn builder() -> crate::operation::get_associated_enclave_certificate_iam_roles::builders::GetAssociatedEnclaveCertificateIamRolesInputBuilder
-119
+    {
         crate::operation::get_associated_enclave_certificate_iam_roles::builders::GetAssociatedEnclaveCertificateIamRolesInputBuilder::default()
-121
+    }
-122
+}
-123
 /// A builder for [`GetAssociatedEnclaveCertificateIamRolesInput`](crate::operation::get_associated_enclave_certificate_iam_roles::GetAssociatedEnclaveCertificateIamRolesInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]

↧ Expand context

 #[non_exhaustive]
 pub struct GetAssociatedEnclaveCertificateIamRolesInputBuilder {
     pub(crate) certificate_arn: ::std::option::Option<::std::string::String>,
     pub(crate) dry_run: ::std::option::Option<bool>,
-130
+}
 impl GetAssociatedEnclaveCertificateIamRolesInputBuilder {
     /// <p>The ARN of the ACM certificate for which to view the associated IAM roles, encryption keys, and Amazon S3 object information.</p>
     /// This field is required.
     pub fn certificate_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.certificate_arn = ::std::option::Option::Some(input.into());
         self
-137
+    }
     /// <p>The ARN of the ACM certificate for which to view the associated IAM roles, encryption keys, and Amazon S3 object information.</p>
     pub fn set_certificate_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.certificate_arn = input;
         self
-142
+    }
     /// <p>The ARN of the ACM certificate for which to view the associated IAM roles, encryption keys, and Amazon S3 object information.</p>
     pub fn get_certificate_arn(&self) -> &::std::option::Option<::std::string::String> {
         &self.certificate_arn

AWS SDK

Files changed: