AWS SDK

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

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

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

@@ -125,129 +184,189 @@

↥ Expand context

-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("CopyImage")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CopyImageEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::copy_image::CopyImageError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::copy_image::CopyImageError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::copy_image::CopyImageError,
             >::new());
-148

         ::std::borrow::Cow::Owned(rcb)
-150
+    }
-151
+}
-152
 #[derive(Debug)]
 struct CopyImageResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CopyImageResponseDeserializer {
     fn deserialize_nonstreaming(
         &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_copy_image::de_copy_image_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_copy_image::de_copy_image_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-173
+    }
-174
+}
 #[derive(Debug)]
 struct CopyImageRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CopyImageRequestSerializer {
     #[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::copy_image::CopyImageInput>().expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {

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

@@ -158,158 +351,351 @@

↥ Expand context

     pub fn snapshot_copy_completion_duration_minutes(&self) -> ::std::option::Option<i64> {
         self.snapshot_copy_completion_duration_minutes
-160
+    }
     /// <p>The Local Zone for the new AMI (for example, <code>cn-north-1-pkx-1a</code>).</p>
     /// <p>Only one of <code>DestinationAvailabilityZone</code>, <code>DestinationAvailabilityZoneId</code>, or <code>DestinationOutpostArn</code> can be specified.</p>
     pub fn destination_availability_zone(&self) -> ::std::option::Option<&str> {
         self.destination_availability_zone.as_deref()
-165
+    }
     /// <p>The ID of the Local Zone for the new AMI (for example, <code>cnn1-pkx1-az1</code>).</p>
     /// <p>Only one of <code>DestinationAvailabilityZone</code>, <code>DestinationAvailabilityZoneId</code>, or <code>DestinationOutpostArn</code> can be specified.</p>
     pub fn destination_availability_zone_id(&self) -> ::std::option::Option<&str> {
         self.destination_availability_zone_id.as_deref()
-170
+    }
     /// <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
-174
+    }
-175
+}
 static COPYIMAGEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CopyImageInput",

     "com.amazonaws.ec2.synthetic",
     "CopyImageInput",
 );
 static COPYIMAGEINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$ClientToken",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
 );
 static COPYIMAGEINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$Description",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "description",
     "Description",
 ,
 );
 static COPYIMAGEINPUT_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$Encrypted",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "encrypted",
     "Encrypted",
 ,
-210
+)
 .with_xml_name("encrypted");
 static COPYIMAGEINPUT_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$KmsKeyId",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "kms_key_id",
     "KmsKeyId",
 ,
-221
+)
 .with_xml_name("kmsKeyId");
 static COPYIMAGEINPUT_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$Name",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "name",
     "Name",
 ,
 );
 static COPYIMAGEINPUT_MEMBER_SOURCE_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$SourceImageId",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "source_image_id",
     "SourceImageId",
 ,
 );
 static COPYIMAGEINPUT_MEMBER_SOURCE_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$SourceRegion",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "source_region",
     "SourceRegion",
 ,
 );
 static COPYIMAGEINPUT_MEMBER_DESTINATION_OUTPOST_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$DestinationOutpostArn",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "destination_outpost_arn",
     "DestinationOutpostArn",
 ,
 );
 static COPYIMAGEINPUT_MEMBER_COPY_IMAGE_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$CopyImageTags",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "copy_image_tags",
     "CopyImageTags",
 ,
 );
 static COPYIMAGEINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$TagSpecifications",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_specifications",
     "TagSpecifications",
 ,
-282
+)
 .with_xml_name("TagSpecification");
 static COPYIMAGEINPUT_MEMBER_SNAPSHOT_COPY_COMPLETION_DURATION_MINUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$SnapshotCopyCompletionDurationMinutes",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "snapshot_copy_completion_duration_minutes",
     "SnapshotCopyCompletionDurationMinutes",
 ,
 );
 static COPYIMAGEINPUT_MEMBER_DESTINATION_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$DestinationAvailabilityZone",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "destination_availability_zone",
     "DestinationAvailabilityZone",
 ,
 );
 static COPYIMAGEINPUT_MEMBER_DESTINATION_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$DestinationAvailabilityZoneId",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "destination_availability_zone_id",
     "DestinationAvailabilityZoneId",
 ,
 );
 static COPYIMAGEINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "CopyImageInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
-323
+)
 .with_xml_name("dryRun");
 static COPYIMAGEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     COPYIMAGEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &COPYIMAGEINPUT_MEMBER_CLIENT_TOKEN,
         &COPYIMAGEINPUT_MEMBER_DESCRIPTION,
         &COPYIMAGEINPUT_MEMBER_ENCRYPTED,

↧ Expand context

         &COPYIMAGEINPUT_MEMBER_KMS_KEY_ID,
         &COPYIMAGEINPUT_MEMBER_NAME,
         &COPYIMAGEINPUT_MEMBER_SOURCE_IMAGE_ID,
         &COPYIMAGEINPUT_MEMBER_SOURCE_REGION,
         &COPYIMAGEINPUT_MEMBER_DESTINATION_OUTPOST_ARN,
         &COPYIMAGEINPUT_MEMBER_COPY_IMAGE_TAGS,
         &COPYIMAGEINPUT_MEMBER_TAG_SPECIFICATIONS,
         &COPYIMAGEINPUT_MEMBER_SNAPSHOT_COPY_COMPLETION_DURATION_MINUTES,
         &COPYIMAGEINPUT_MEMBER_DESTINATION_AVAILABILITY_ZONE,
         &COPYIMAGEINPUT_MEMBER_DESTINATION_AVAILABILITY_ZONE_ID,
         &COPYIMAGEINPUT_MEMBER_DRY_RUN,
     ],
 );
 impl CopyImageInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COPYIMAGEINPUT_SCHEMA;
-348
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CopyImageInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(

@@ -380,380 +514,525 @@

↥ Expand context

             ser.write_boolean(&COPYIMAGEINPUT_MEMBER_COPY_IMAGE_TAGS, *val)?;
-381
+        }
         if let Some(ref val) = self.tag_specifications {
             ser.write_list(
                 &COPYIMAGEINPUT_MEMBER_TAG_SPECIFICATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
-388
+                    }
                     Ok(())
                 },
             )?;
-392
+        }
         if let Some(ref val) = self.snapshot_copy_completion_duration_minutes {
             ser.write_long(&COPYIMAGEINPUT_MEMBER_SNAPSHOT_COPY_COMPLETION_DURATION_MINUTES, *val)?;
-395
+        }
         if let Some(ref val) = self.destination_availability_zone {
             ser.write_string(&COPYIMAGEINPUT_MEMBER_DESTINATION_AVAILABILITY_ZONE, val)?;
-398
+        }
         if let Some(ref val) = self.destination_availability_zone_id {

             ser.write_string(&COPYIMAGEINPUT_MEMBER_DESTINATION_AVAILABILITY_ZONE_ID, val)?;
-401
+        }
         if let Some(ref val) = self.dry_run {
             ser.write_boolean(&COPYIMAGEINPUT_MEMBER_DRY_RUN, *val)?;
-404
+        }
         Ok(())
-406
+    }
-407
+}
 impl CopyImageInput {
     /// 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(&COPYIMAGEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&COPYIMAGEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.client_token = Some(deser.read_string(member)?);
-426
+                }
                 Some(1) => {
                     builder.description = Some(deser.read_string(member)?);
-429
+                }
                 Some(2) => {
                     builder.encrypted = Some(deser.read_boolean(member)?);
-432
+                }
                 Some(3) => {
                     builder.kms_key_id = Some(deser.read_string(member)?);
-435
+                }
                 Some(4) => {
                     builder.name = Some(deser.read_string(member)?);
-438
+                }
                 Some(5) => {
                     builder.source_image_id = Some(deser.read_string(member)?);
-441
+                }
                 Some(6) => {
                     builder.source_region = Some(deser.read_string(member)?);
-444
+                }
                 Some(7) => {
                     builder.destination_outpost_arn = Some(deser.read_string(member)?);
-447
+                }
                 Some(8) => {
                     builder.copy_image_tags = Some(deser.read_boolean(member)?);
-450
+                }
                 Some(9) => {
                     builder.tag_specifications = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-460
+                }
                 Some(10) => {
                     builder.snapshot_copy_completion_duration_minutes = Some(deser.read_long(member)?);
-463
+                }
                 Some(11) => {
                     builder.destination_availability_zone = Some(deser.read_string(member)?);
-466
+                }
                 Some(12) => {
                     builder.destination_availability_zone_id = Some(deser.read_string(member)?);
-469
+                }
                 Some(13) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-472
+                }
                 _ => {}
-474
+            }
             Ok(())
         })?;
         builder.name = builder.name.or(Some(String::new()));
         builder.source_image_id = builder.source_image_id.or(Some(String::new()));
         builder.source_region = builder.source_region.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-483
+    }
-484
+}
 impl CopyImageInput {
     /// 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 CopyImageInput {
     /// Creates a new builder-style object to manufacture [`CopyImageInput`](crate::operation::copy_image::CopyImageInput).
     pub fn builder() -> crate::operation::copy_image::builders::CopyImageInputBuilder {
         crate::operation::copy_image::builders::CopyImageInputBuilder::default()
-500
+    }
-501
+}
-502
 /// A builder for [`CopyImageInput`](crate::operation::copy_image::CopyImageInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CopyImageInputBuilder {
     pub(crate) client_token: ::std::option::Option<::std::string::String>,
     pub(crate) description: ::std::option::Option<::std::string::String>,
     pub(crate) encrypted: ::std::option::Option<bool>,
     pub(crate) kms_key_id: ::std::option::Option<::std::string::String>,
     pub(crate) name: ::std::option::Option<::std::string::String>,
     pub(crate) source_image_id: ::std::option::Option<::std::string::String>,
     pub(crate) source_region: ::std::option::Option<::std::string::String>,
     pub(crate) destination_outpost_arn: ::std::option::Option<::std::string::String>,
     pub(crate) copy_image_tags: ::std::option::Option<bool>,
     pub(crate) tag_specifications: ::std::option::Option<::std::vec::Vec<crate::types::TagSpecification>>,
     pub(crate) snapshot_copy_completion_duration_minutes: ::std::option::Option<i64>,
     pub(crate) destination_availability_zone: ::std::option::Option<::std::string::String>,
     pub(crate) destination_availability_zone_id: ::std::option::Option<::std::string::String>,
     pub(crate) dry_run: ::std::option::Option<bool>,
-521
+}
 impl CopyImageInputBuilder {
     /// <p>Unique, case-sensitive identifier you provide to ensure idempotency of the request. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html">Ensuring idempotency in Amazon EC2 API requests</a> in the <i>Amazon EC2 API Reference</i>.</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());

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

@@ -1,1 +98,142 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Contains the output of CopyImage.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct CopyImageOutput {
     /// <p>The ID of the new AMI.</p>
     pub image_id: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-10
+}
 impl CopyImageOutput {
     /// <p>The ID of the new AMI.</p>
     pub fn image_id(&self) -> ::std::option::Option<&str> {
         self.image_id.as_deref()
-15
+    }
-16
+}
 static COPYIMAGEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CopyImageOutput",

     "com.amazonaws.ec2.synthetic",
     "CopyImageOutput",
 );
 static COPYIMAGEOUTPUT_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopyImageOutput$ImageId",
         "com.amazonaws.ec2.synthetic",
         "CopyImageOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "image_id",
     "ImageId",
 ,
-31
+)
 .with_xml_name("imageId");
 static COPYIMAGEOUTPUT_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 COPYIMAGEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     COPYIMAGEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&COPYIMAGEOUTPUT_MEMBER_IMAGE_ID],
     &[&COPYIMAGEOUTPUT_MEMBER_IMAGE_ID, &COPYIMAGEOUTPUT_MEMBER__REQUEST_ID],
 );
 impl CopyImageOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COPYIMAGEOUTPUT_SCHEMA;
-48
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CopyImageOutput {
     #[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.image_id {
             ser.write_string(&COPYIMAGEOUTPUT_MEMBER_IMAGE_ID, val)?;
-57
+        }
         Ok(())
-59
+    }
-60
+}
 impl CopyImageOutput {
     /// 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(&COPYIMAGEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.image_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CopyImageOutput {
     /// 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(&COPYIMAGEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&COPYIMAGEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.image_id = Some(deser.read_string(member)?);
-116
+                }
                 _ => {}
-118
+            }
             Ok(())
         })?;
         Ok(builder.build())
-122
+    }

↧ Expand context

-123
+}
 impl ::aws_types::request_id::RequestId for CopyImageOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-127
+    }
-128
+}
 impl CopyImageOutput {
     /// Creates a new builder-style object to manufacture [`CopyImageOutput`](crate::operation::copy_image::CopyImageOutput).
     pub fn builder() -> crate::operation::copy_image::builders::CopyImageOutputBuilder {
         crate::operation::copy_image::builders::CopyImageOutputBuilder::default()
-133
+    }
-134
+}
-135
 /// A builder for [`CopyImageOutput`](crate::operation::copy_image::CopyImageOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CopyImageOutputBuilder {
     pub(crate) image_id: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-142
+}

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

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

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

@@ -118,122 +177,182 @@

↥ Expand context

-122
+    }
-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CopySnapshot")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CopySnapshotEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::copy_snapshot::CopySnapshotError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::copy_snapshot::CopySnapshotError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::copy_snapshot::CopySnapshotError,
             >::new());
-141

         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct CopySnapshotResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CopySnapshotResponseDeserializer {
     fn deserialize_nonstreaming(
         &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_copy_snapshot::de_copy_snapshot_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_copy_snapshot::de_copy_snapshot_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-166
+    }
-167
+}
 #[derive(Debug)]
 struct CopySnapshotRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CopySnapshotRequestSerializer {
     #[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::copy_snapshot::CopySnapshotInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

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

@@ -129,129 +304,304 @@

↥ Expand context

 impl ::std::fmt::Debug for CopySnapshotInput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("CopySnapshotInput");
         formatter.field("description", &self.description);
         formatter.field("destination_outpost_arn", &self.destination_outpost_arn);
         formatter.field("destination_region", &self.destination_region);
         formatter.field("encrypted", &self.encrypted);
         formatter.field("kms_key_id", &self.kms_key_id);
         formatter.field("presigned_url", &"*** Sensitive Data Redacted ***");
         formatter.field("source_region", &self.source_region);
         formatter.field("source_snapshot_id", &self.source_snapshot_id);
         formatter.field("tag_specifications", &self.tag_specifications);
         formatter.field("completion_duration_minutes", &self.completion_duration_minutes);
         formatter.field("destination_availability_zone", &self.destination_availability_zone);
         formatter.field("dry_run", &self.dry_run);
         formatter.finish()
-145
+    }
-146
+}
 static COPYSNAPSHOTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CopySnapshotInput",

     "com.amazonaws.ec2.synthetic",
     "CopySnapshotInput",
 );
 static COPYSNAPSHOTINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotInput$Description",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "description",
     "Description",
 ,
 );
 static COPYSNAPSHOTINPUT_MEMBER_DESTINATION_OUTPOST_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotInput$DestinationOutpostArn",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "destination_outpost_arn",
     "DestinationOutpostArn",
 ,
 );
 static COPYSNAPSHOTINPUT_MEMBER_DESTINATION_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotInput$DestinationRegion",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "destination_region",
     "DestinationRegion",
 ,
-181
+)
 .with_xml_name("destinationRegion");
 static COPYSNAPSHOTINPUT_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotInput$Encrypted",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "encrypted",
     "Encrypted",
 ,
-192
+)
 .with_xml_name("encrypted");
 static COPYSNAPSHOTINPUT_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotInput$KmsKeyId",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "kms_key_id",
     "KmsKeyId",
 ,
-203
+)
 .with_xml_name("kmsKeyId");
 static COPYSNAPSHOTINPUT_MEMBER_PRESIGNED_URL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotInput$PresignedUrl",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "presigned_url",
     "PresignedUrl",
 ,
-214
+)
 .with_xml_name("presignedUrl");
 static COPYSNAPSHOTINPUT_MEMBER_SOURCE_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotInput$SourceRegion",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "source_region",
     "SourceRegion",
 ,
 );
 static COPYSNAPSHOTINPUT_MEMBER_SOURCE_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotInput$SourceSnapshotId",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "source_snapshot_id",
     "SourceSnapshotId",
 ,
 );
 static COPYSNAPSHOTINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotInput$TagSpecifications",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_specifications",
     "TagSpecifications",
 ,
-245
+)
 .with_xml_name("TagSpecification");
 static COPYSNAPSHOTINPUT_MEMBER_COMPLETION_DURATION_MINUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotInput$CompletionDurationMinutes",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "completion_duration_minutes",
     "CompletionDurationMinutes",
 ,
 );
 static COPYSNAPSHOTINPUT_MEMBER_DESTINATION_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotInput$DestinationAvailabilityZone",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "destination_availability_zone",
     "DestinationAvailabilityZone",
 ,
 );
 static COPYSNAPSHOTINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
-276
+)
 .with_xml_name("dryRun");
 static COPYSNAPSHOTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     COPYSNAPSHOTINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &COPYSNAPSHOTINPUT_MEMBER_DESCRIPTION,
         &COPYSNAPSHOTINPUT_MEMBER_DESTINATION_OUTPOST_ARN,
         &COPYSNAPSHOTINPUT_MEMBER_DESTINATION_REGION,

↧ Expand context

         &COPYSNAPSHOTINPUT_MEMBER_ENCRYPTED,
         &COPYSNAPSHOTINPUT_MEMBER_KMS_KEY_ID,
         &COPYSNAPSHOTINPUT_MEMBER_PRESIGNED_URL,
         &COPYSNAPSHOTINPUT_MEMBER_SOURCE_REGION,
         &COPYSNAPSHOTINPUT_MEMBER_SOURCE_SNAPSHOT_ID,
         &COPYSNAPSHOTINPUT_MEMBER_TAG_SPECIFICATIONS,
         &COPYSNAPSHOTINPUT_MEMBER_COMPLETION_DURATION_MINUTES,
         &COPYSNAPSHOTINPUT_MEMBER_DESTINATION_AVAILABILITY_ZONE,
         &COPYSNAPSHOTINPUT_MEMBER_DRY_RUN,
     ],
 );
 impl CopySnapshotInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COPYSNAPSHOTINPUT_SCHEMA;
-299
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CopySnapshotInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,

@@ -325,325 +453,463 @@

↥ Expand context

             ser.write_string(&COPYSNAPSHOTINPUT_MEMBER_SOURCE_REGION, val)?;
-326
+        }
         if let Some(ref val) = self.source_snapshot_id {
             ser.write_string(&COPYSNAPSHOTINPUT_MEMBER_SOURCE_SNAPSHOT_ID, val)?;
-329
+        }
         if let Some(ref val) = self.tag_specifications {
             ser.write_list(
                 &COPYSNAPSHOTINPUT_MEMBER_TAG_SPECIFICATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
-336
+                    }
                     Ok(())
                 },
             )?;
-340
+        }
         if let Some(ref val) = self.completion_duration_minutes {
             ser.write_integer(&COPYSNAPSHOTINPUT_MEMBER_COMPLETION_DURATION_MINUTES, *val)?;
-343
+        }
         if let Some(ref val) = self.destination_availability_zone {

             ser.write_string(&COPYSNAPSHOTINPUT_MEMBER_DESTINATION_AVAILABILITY_ZONE, val)?;
-346
+        }
         if let Some(ref val) = self.dry_run {
             ser.write_boolean(&COPYSNAPSHOTINPUT_MEMBER_DRY_RUN, *val)?;
-349
+        }
         Ok(())
-351
+    }
-352
+}
 impl CopySnapshotInput {
     /// 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(&COPYSNAPSHOTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&COPYSNAPSHOTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.description = Some(deser.read_string(member)?);
-371
+                }
                 Some(1) => {
                     builder.destination_outpost_arn = Some(deser.read_string(member)?);
-374
+                }
                 Some(2) => {
                     builder.destination_region = Some(deser.read_string(member)?);
-377
+                }
                 Some(3) => {
                     builder.encrypted = Some(deser.read_boolean(member)?);
-380
+                }
                 Some(4) => {
                     builder.kms_key_id = Some(deser.read_string(member)?);
-383
+                }
                 Some(5) => {
                     builder.presigned_url = Some(deser.read_string(member)?);
-386
+                }
                 Some(6) => {
                     builder.source_region = Some(deser.read_string(member)?);
-389
+                }
                 Some(7) => {
                     builder.source_snapshot_id = Some(deser.read_string(member)?);
-392
+                }
                 Some(8) => {
                     builder.tag_specifications = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-402
+                }
                 Some(9) => {
                     builder.completion_duration_minutes = Some(deser.read_integer(member)?);
-405
+                }
                 Some(10) => {
                     builder.destination_availability_zone = Some(deser.read_string(member)?);
-408
+                }
                 Some(11) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-411
+                }
                 _ => {}
-413
+            }
             Ok(())
         })?;
         builder.source_region = builder.source_region.or(Some(String::new()));
         builder.source_snapshot_id = builder.source_snapshot_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-421
+    }
-422
+}
 impl CopySnapshotInput {
     /// 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 CopySnapshotInput {
     /// Creates a new builder-style object to manufacture [`CopySnapshotInput`](crate::operation::copy_snapshot::CopySnapshotInput).
     pub fn builder() -> crate::operation::copy_snapshot::builders::CopySnapshotInputBuilder {
         crate::operation::copy_snapshot::builders::CopySnapshotInputBuilder::default()
-438
+    }
-439
+}
-440
 /// A builder for [`CopySnapshotInput`](crate::operation::copy_snapshot::CopySnapshotInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct CopySnapshotInputBuilder {
     pub(crate) description: ::std::option::Option<::std::string::String>,
     pub(crate) destination_outpost_arn: ::std::option::Option<::std::string::String>,
     pub(crate) destination_region: ::std::option::Option<::std::string::String>,
     pub(crate) encrypted: ::std::option::Option<bool>,
     pub(crate) kms_key_id: ::std::option::Option<::std::string::String>,
     pub(crate) presigned_url: ::std::option::Option<::std::string::String>,
     pub(crate) source_region: ::std::option::Option<::std::string::String>,
     pub(crate) source_snapshot_id: ::std::option::Option<::std::string::String>,
     pub(crate) tag_specifications: ::std::option::Option<::std::vec::Vec<crate::types::TagSpecification>>,
     pub(crate) completion_duration_minutes: ::std::option::Option<i32>,
     pub(crate) destination_availability_zone: ::std::option::Option<::std::string::String>,
     pub(crate) dry_run: ::std::option::Option<bool>,
-457
+}
 impl CopySnapshotInputBuilder {
     /// <p>A description for the EBS snapshot.</p>
     pub fn description(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.description = ::std::option::Option::Some(input.into());
         self
-463
+    }

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

@@ -6,6 +139,194 @@

↥ Expand context

     /// <p>Any tags applied to the new snapshot.</p>
     pub tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     /// <p>The ID of the new snapshot.</p>
     pub snapshot_id: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-11
+}
 impl CopySnapshotOutput {
     /// <p>Any tags applied to the new snapshot.</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()
-18
+    }
     /// <p>The ID of the new snapshot.</p>
     pub fn snapshot_id(&self) -> ::std::option::Option<&str> {
         self.snapshot_id.as_deref()
-22
+    }
-23
+}
 static COPYSNAPSHOTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CopySnapshotOutput",

     "com.amazonaws.ec2.synthetic",
     "CopySnapshotOutput",
 );
 static COPYSNAPSHOTOUTPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotOutput$Tags",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-38
+)
 .with_xml_name("tagSet");
 static COPYSNAPSHOTOUTPUT_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CopySnapshotOutput$SnapshotId",
         "com.amazonaws.ec2.synthetic",
         "CopySnapshotOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "snapshot_id",
     "SnapshotId",
 ,
-49
+)
 .with_xml_name("snapshotId");
 static COPYSNAPSHOTOUTPUT_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 COPYSNAPSHOTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     COPYSNAPSHOTOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&COPYSNAPSHOTOUTPUT_MEMBER_TAGS, &COPYSNAPSHOTOUTPUT_MEMBER_SNAPSHOT_ID],
     &[
         &COPYSNAPSHOTOUTPUT_MEMBER_TAGS,
         &COPYSNAPSHOTOUTPUT_MEMBER_SNAPSHOT_ID,
         &COPYSNAPSHOTOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl CopySnapshotOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COPYSNAPSHOTOUTPUT_SCHEMA;
-70
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CopySnapshotOutput {
     #[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.tags {
             ser.write_list(
                 &COPYSNAPSHOTOUTPUT_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-83
+                    }
                     Ok(())
                 },
             )?;
-87
+        }
         if let Some(ref val) = self.snapshot_id {
             ser.write_string(&COPYSNAPSHOTOUTPUT_MEMBER_SNAPSHOT_ID, val)?;
-90
+        }
         Ok(())
-92
+    }
-93
+}
 impl CopySnapshotOutput {
     /// 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(&COPYSNAPSHOTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.tags = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(1) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CopySnapshotOutput {
     /// 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(&COPYSNAPSHOTOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&COPYSNAPSHOTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     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
                     });
-166
+                }
                 Some(1) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-169
+                }
                 _ => {}
-171
+            }
             Ok(())
         })?;
         Ok(builder.build())

↧ Expand context

-175
+    }
-176
+}
 impl ::aws_types::request_id::RequestId for CopySnapshotOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-180
+    }
-181
+}
 impl CopySnapshotOutput {
     /// Creates a new builder-style object to manufacture [`CopySnapshotOutput`](crate::operation::copy_snapshot::CopySnapshotOutput).
     pub fn builder() -> crate::operation::copy_snapshot::builders::CopySnapshotOutputBuilder {
         crate::operation::copy_snapshot::builders::CopySnapshotOutputBuilder::default()
-186
+    }
-187
+}
-188
 /// A builder for [`CopySnapshotOutput`](crate::operation::copy_snapshot::CopySnapshotOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CopySnapshotOutputBuilder {
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) snapshot_id: ::std::option::Option<::std::string::String>,

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

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

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

↧ Expand context

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

@@ -121,127 +180,187 @@

↥ Expand context

-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("CreateCapacityReservation")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateCapacityReservationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_capacity_reservation::CreateCapacityReservationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_capacity_reservation::CreateCapacityReservationError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::create_capacity_reservation::CreateCapacityReservationError,
             >::new());
-146

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

↧ Expand context

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

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

@@ -205,205 +445,445 @@

↥ Expand context

     /// <note>
     /// <p>Required for future-dated Capacity Reservations only. To create a Capacity Reservation for immediate use, omit this parameter.</p>
     /// </note>
     /// <p>Specify a commitment duration, in seconds, for the future-dated Capacity Reservation.</p>
     /// <p>The commitment duration is a minimum duration for which you commit to having the future-dated Capacity Reservation in the <code>active</code> state in your account after it has been delivered.</p>
     /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cr-concepts.html#cr-commitment-duration"> Commitment duration</a>.</p>
     pub fn commitment_duration(&self) -> ::std::option::Option<i64> {
         self.commitment_duration
-213
+    }
     /// <note>
     /// <p>Required for future-dated Capacity Reservations only. To create a Capacity Reservation for immediate use, omit this parameter.</p>
     /// </note>
     /// <p>Indicates that the requested capacity will be delivered in addition to any running instances or reserved capacity that you have in your account at the requested date and time.</p>
     /// <p>The only supported value is <code>incremental</code>.</p>
     pub fn delivery_preference(&self) -> ::std::option::Option<&crate::types::CapacityReservationDeliveryPreference> {
         self.delivery_preference.as_ref()
-221
+    }
-222
+}
 static CREATECAPACITYRESERVATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput",

     "com.amazonaws.ec2.synthetic",
     "CreateCapacityReservationInput",
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$ClientToken",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$InstanceType",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_type",
     "InstanceType",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$InstancePlatform",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_platform",
     "InstancePlatform",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$AvailabilityZone",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone",
     "AvailabilityZone",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$AvailabilityZoneId",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "availability_zone_id",
     "AvailabilityZoneId",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_TENANCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$Tenancy",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "tenancy",
     "Tenancy",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$InstanceCount",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "instance_count",
     "InstanceCount",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_EBS_OPTIMIZED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$EbsOptimized",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "ebs_optimized",
     "EbsOptimized",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_EPHEMERAL_STORAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$EphemeralStorage",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "ephemeral_storage",
     "EphemeralStorage",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$EndDate",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "end_date",
     "EndDate",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_END_DATE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$EndDateType",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "end_date_type",
     "EndDateType",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_MATCH_CRITERIA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$InstanceMatchCriteria",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_match_criteria",
     "InstanceMatchCriteria",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$TagSpecifications",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_specifications",
     "TagSpecifications",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_OUTPOST_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$OutpostArn",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "outpost_arn",
     "OutpostArn",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_PLACEMENT_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$PlacementGroupArn",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "placement_group_arn",
     "PlacementGroupArn",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_START_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$StartDate",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "start_date",
     "StartDate",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_COMMITMENT_DURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$CommitmentDuration",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "commitment_duration",
     "CommitmentDuration",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_MEMBER_DELIVERY_PREFERENCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationInput$DeliveryPreference",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "delivery_preference",
     "DeliveryPreference",
 ,
 );
 static CREATECAPACITYRESERVATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATECAPACITYRESERVATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_CLIENT_TOKEN,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_TYPE,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_PLATFORM,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_AVAILABILITY_ZONE,

↧ Expand context

         &CREATECAPACITYRESERVATIONINPUT_MEMBER_AVAILABILITY_ZONE_ID,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_TENANCY,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_COUNT,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_EBS_OPTIMIZED,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_EPHEMERAL_STORAGE,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_END_DATE,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_END_DATE_TYPE,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_MATCH_CRITERIA,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_TAG_SPECIFICATIONS,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_DRY_RUN,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_OUTPOST_ARN,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_PLACEMENT_GROUP_ARN,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_START_DATE,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_COMMITMENT_DURATION,
         &CREATECAPACITYRESERVATIONINPUT_MEMBER_DELIVERY_PREFERENCE,
     ],
 );
 impl CreateCapacityReservationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATECAPACITYRESERVATIONINPUT_SCHEMA;

@@ -493,493 +646,656 @@

↥ Expand context

                     for item in val {
                         ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
-495
+                    }
                     Ok(())
                 },
             )?;
-499
+        }
         if let Some(ref val) = self.dry_run {
             ser.write_boolean(&CREATECAPACITYRESERVATIONINPUT_MEMBER_DRY_RUN, *val)?;
-502
+        }
         if let Some(ref val) = self.outpost_arn {
             ser.write_string(&CREATECAPACITYRESERVATIONINPUT_MEMBER_OUTPOST_ARN, val)?;
-505
+        }
         if let Some(ref val) = self.placement_group_arn {
             ser.write_string(&CREATECAPACITYRESERVATIONINPUT_MEMBER_PLACEMENT_GROUP_ARN, val)?;
-508
+        }
         if let Some(ref val) = self.start_date {
             ser.write_timestamp(&CREATECAPACITYRESERVATIONINPUT_MEMBER_START_DATE, val)?;
-511
+        }
         if let Some(ref val) = self.commitment_duration {

             ser.write_long(&CREATECAPACITYRESERVATIONINPUT_MEMBER_COMMITMENT_DURATION, *val)?;
-514
+        }
         if let Some(ref val) = self.delivery_preference {
             ser.write_string(&CREATECAPACITYRESERVATIONINPUT_MEMBER_DELIVERY_PREFERENCE, val.as_str())?;
-517
+        }
         Ok(())
-519
+    }
-520
+}
 impl CreateCapacityReservationInput {
     /// 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(&CREATECAPACITYRESERVATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATECAPACITYRESERVATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.client_token = Some(deser.read_string(member)?);
-539
+                }
                 Some(1) => {
                     builder.instance_type = Some(deser.read_string(member)?);
-542
+                }
                 Some(2) => {
                     builder.instance_platform = Some(crate::types::CapacityReservationInstancePlatform::from(
                         deser.read_string(member)?.as_str(),
                     ));
-547
+                }
                 Some(3) => {
                     builder.availability_zone = Some(deser.read_string(member)?);
-550
+                }
                 Some(4) => {
                     builder.availability_zone_id = Some(deser.read_string(member)?);
-553
+                }
                 Some(5) => {
                     builder.tenancy = Some(crate::types::CapacityReservationTenancy::from(deser.read_string(member)?.as_str()));
-556
+                }
                 Some(6) => {
                     builder.instance_count = Some(deser.read_integer(member)?);
-559
+                }
                 Some(7) => {
                     builder.ebs_optimized = Some(deser.read_boolean(member)?);
-562
+                }
                 Some(8) => {
                     builder.ephemeral_storage = Some(deser.read_boolean(member)?);
-565
+                }
                 Some(9) => {
                     builder.end_date = Some(deser.read_timestamp(member)?);
-568
+                }
                 Some(10) => {
                     builder.end_date_type = Some(crate::types::EndDateType::from(deser.read_string(member)?.as_str()));
-571
+                }
                 Some(11) => {
                     builder.instance_match_criteria = Some(crate::types::InstanceMatchCriteria::from(deser.read_string(member)?.as_str()));
-574
+                }
                 Some(12) => {
                     builder.tag_specifications = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-584
+                }
                 Some(13) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-587
+                }
                 Some(14) => {
                     builder.outpost_arn = Some(deser.read_string(member)?);
-590
+                }
                 Some(15) => {
                     builder.placement_group_arn = Some(deser.read_string(member)?);
-593
+                }
                 Some(16) => {
                     builder.start_date = Some(deser.read_timestamp(member)?);
-596
+                }
                 Some(17) => {
                     builder.commitment_duration = Some(deser.read_long(member)?);
-599
+                }
                 Some(18) => {
                     builder.delivery_preference = Some(crate::types::CapacityReservationDeliveryPreference::from(
                         deser.read_string(member)?.as_str(),
                     ));
-604
+                }
                 _ => {}
-606
+            }
             Ok(())
         })?;
         builder.instance_type = builder.instance_type.or(Some(String::new()));
         builder.instance_count = builder.instance_count.or(Some(0i32));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-614
+    }
-615
+}
 impl CreateCapacityReservationInput {
     /// 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 CreateCapacityReservationInput {
     /// Creates a new builder-style object to manufacture [`CreateCapacityReservationInput`](crate::operation::create_capacity_reservation::CreateCapacityReservationInput).
     pub fn builder() -> crate::operation::create_capacity_reservation::builders::CreateCapacityReservationInputBuilder {
         crate::operation::create_capacity_reservation::builders::CreateCapacityReservationInputBuilder::default()
-631
+    }
-632
+}
-633
 /// A builder for [`CreateCapacityReservationInput`](crate::operation::create_capacity_reservation::CreateCapacityReservationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CreateCapacityReservationInputBuilder {
     pub(crate) client_token: ::std::option::Option<::std::string::String>,
     pub(crate) instance_type: ::std::option::Option<::std::string::String>,
     pub(crate) instance_platform: ::std::option::Option<crate::types::CapacityReservationInstancePlatform>,
     pub(crate) availability_zone: ::std::option::Option<::std::string::String>,
     pub(crate) availability_zone_id: ::std::option::Option<::std::string::String>,
     pub(crate) tenancy: ::std::option::Option<crate::types::CapacityReservationTenancy>,
     pub(crate) instance_count: ::std::option::Option<i32>,
     pub(crate) ebs_optimized: ::std::option::Option<bool>,
     pub(crate) ephemeral_storage: ::std::option::Option<bool>,
     pub(crate) end_date: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) end_date_type: ::std::option::Option<crate::types::EndDateType>,
     pub(crate) instance_match_criteria: ::std::option::Option<crate::types::InstanceMatchCriteria>,
     pub(crate) tag_specifications: ::std::option::Option<::std::vec::Vec<crate::types::TagSpecification>>,
     pub(crate) dry_run: ::std::option::Option<bool>,
     pub(crate) outpost_arn: ::std::option::Option<::std::string::String>,
     pub(crate) placement_group_arn: ::std::option::Option<::std::string::String>,
     pub(crate) start_date: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) commitment_duration: ::std::option::Option<i64>,
     pub(crate) delivery_preference: ::std::option::Option<crate::types::CapacityReservationDeliveryPreference>,

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_capacity_reservation/_create_capacity_reservation_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 CreateCapacityReservationOutput {
     /// <p>Information about the Capacity Reservation.</p>
     pub capacity_reservation: ::std::option::Option<crate::types::CapacityReservation>,
     _request_id: Option<String>,
-9
+}
 impl CreateCapacityReservationOutput {
     /// <p>Information about the Capacity Reservation.</p>
     pub fn capacity_reservation(&self) -> ::std::option::Option<&crate::types::CapacityReservation> {
         self.capacity_reservation.as_ref()
-14
+    }
-15
+}
 static CREATECAPACITYRESERVATIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateCapacityReservationOutput",

     "com.amazonaws.ec2.synthetic",
     "CreateCapacityReservationOutput",
 );
 static CREATECAPACITYRESERVATIONOUTPUT_MEMBER_CAPACITY_RESERVATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationOutput$CapacityReservation",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "capacity_reservation",
     "CapacityReservation",
 ,
-30
+)
 .with_xml_name("capacityReservation");
 static CREATECAPACITYRESERVATIONOUTPUT_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 CREATECAPACITYRESERVATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATECAPACITYRESERVATIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CREATECAPACITYRESERVATIONOUTPUT_MEMBER_CAPACITY_RESERVATION],
     &[
         &CREATECAPACITYRESERVATIONOUTPUT_MEMBER_CAPACITY_RESERVATION,
         &CREATECAPACITYRESERVATIONOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl CreateCapacityReservationOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATECAPACITYRESERVATIONOUTPUT_SCHEMA;
-50
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateCapacityReservationOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.capacity_reservation {
             ser.write_struct(&CREATECAPACITYRESERVATIONOUTPUT_MEMBER_CAPACITY_RESERVATION, val)?;
-59
+        }
         Ok(())
-61
+    }
-62
+}
 impl CreateCapacityReservationOutput {
     /// 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(&CREATECAPACITYRESERVATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATECAPACITYRESERVATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.capacity_reservation = Some(crate::types::CapacityReservation::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateCapacityReservationOutput {
     /// 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(&CREATECAPACITYRESERVATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.capacity_reservation = Some(crate::types::CapacityReservation::deserialize(deser)?);
-118
+                }
                 _ => {}
-120
+            }
             Ok(())
         })?;
         Ok(builder.build())
-124
+    }

↧ Expand context

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

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

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

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

↧ Expand context

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

@@ -135,141 +194,201 @@

↥ Expand context

-141
+    }
-142
     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("CreateCapacityReservationBySplitting")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateCapacityReservationBySplittingEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_capacity_reservation_by_splitting::CreateCapacityReservationBySplittingError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_capacity_reservation_by_splitting::CreateCapacityReservationBySplittingError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::create_capacity_reservation_by_splitting::CreateCapacityReservationBySplittingError,
             >::new());
-160

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

↧ Expand context

-182
+            )
         } else {
             crate::protocol_serde::shape_create_capacity_reservation_by_splitting::de_create_capacity_reservation_by_splitting_http_response(
                 status, headers, body,
-186
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
-189
+    }
-190
+}
 #[derive(Debug)]
 struct CreateCapacityReservationBySplittingRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateCapacityReservationBySplittingRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::create_capacity_reservation_by_splitting::CreateCapacityReservationBySplittingInput>()

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

@@ -23,23 +224,234 @@

↥ Expand context

     pub fn client_token(&self) -> ::std::option::Option<&str> {
         self.client_token.as_deref()
-25
+    }
     /// <p>The ID of the Capacity Reservation from which you want to split the capacity.</p>
     pub fn source_capacity_reservation_id(&self) -> ::std::option::Option<&str> {
         self.source_capacity_reservation_id.as_deref()
-29
+    }
     /// <p>The number of instances to split from the source Capacity Reservation.</p>
     pub fn instance_count(&self) -> ::std::option::Option<i32> {
         self.instance_count
-33
+    }
     /// <p>The tags to apply to the new Capacity Reservation.</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()
-39
+    }
-40
+}
 static CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateCapacityReservationBySplittingInput",

     "com.amazonaws.ec2.synthetic",
     "CreateCapacityReservationBySplittingInput",
 );
 static CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationBySplittingInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationBySplittingInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationBySplittingInput$ClientToken",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationBySplittingInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
 );
 static CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_SOURCE_CAPACITY_RESERVATION_ID: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#CreateCapacityReservationBySplittingInput$SourceCapacityReservationId",
             "com.amazonaws.ec2.synthetic",
             "CreateCapacityReservationBySplittingInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "source_capacity_reservation_id",
         "SourceCapacityReservationId",
 ,
     );
 static CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_INSTANCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationBySplittingInput$InstanceCount",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationBySplittingInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "instance_count",
     "InstanceCount",
 ,
 );
 static CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationBySplittingInput$TagSpecifications",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationBySplittingInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_specifications",
     "TagSpecifications",
 ,
-96
+)
 .with_xml_name("TagSpecification");
 static CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_DRY_RUN,
         &CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_CLIENT_TOKEN,
         &CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_SOURCE_CAPACITY_RESERVATION_ID,
         &CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_INSTANCE_COUNT,
         &CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_TAG_SPECIFICATIONS,
     ],
 );
 impl CreateCapacityReservationBySplittingInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_SCHEMA;
-112
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateCapacityReservationBySplittingInput {
     #[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(&CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_DRY_RUN, *val)?;
-121
+        }
         if let Some(ref val) = self.client_token {
             ser.write_string(&CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_CLIENT_TOKEN, val)?;
-124
+        }
         if let Some(ref val) = self.source_capacity_reservation_id {
             ser.write_string(&CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_SOURCE_CAPACITY_RESERVATION_ID, val)?;
-127
+        }
         if let Some(ref val) = self.instance_count {
             ser.write_integer(&CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_INSTANCE_COUNT, *val)?;
-130
+        }
         if let Some(ref val) = self.tag_specifications {
             ser.write_list(
                 &CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_MEMBER_TAG_SPECIFICATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
-137
+                    }
                     Ok(())
                 },
             )?;
-141
+        }
         Ok(())
-143
+    }
-144
+}
 impl CreateCapacityReservationBySplittingInput {
     /// 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(&CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATECAPACITYRESERVATIONBYSPLITTINGINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-163
+                }
                 Some(1) => {
                     builder.client_token = Some(deser.read_string(member)?);
-166
+                }
                 Some(2) => {
                     builder.source_capacity_reservation_id = Some(deser.read_string(member)?);
-169
+                }
                 Some(3) => {
                     builder.instance_count = Some(deser.read_integer(member)?);
-172
+                }
                 Some(4) => {
                     builder.tag_specifications = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TagSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-182
+                }
                 _ => {}
-184
+            }
             Ok(())
         })?;
         builder.source_capacity_reservation_id = builder.source_capacity_reservation_id.or(Some(String::new()));
         builder.instance_count = builder.instance_count.or(Some(0i32));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-192
+    }
-193
+}
 impl CreateCapacityReservationBySplittingInput {
     /// 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 CreateCapacityReservationBySplittingInput {
     /// Creates a new builder-style object to manufacture [`CreateCapacityReservationBySplittingInput`](crate::operation::create_capacity_reservation_by_splitting::CreateCapacityReservationBySplittingInput).
     pub fn builder() -> crate::operation::create_capacity_reservation_by_splitting::builders::CreateCapacityReservationBySplittingInputBuilder {
         crate::operation::create_capacity_reservation_by_splitting::builders::CreateCapacityReservationBySplittingInputBuilder::default()
-209
+    }
-210
+}
-211
 /// A builder for [`CreateCapacityReservationBySplittingInput`](crate::operation::create_capacity_reservation_by_splitting::CreateCapacityReservationBySplittingInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CreateCapacityReservationBySplittingInputBuilder {
     pub(crate) dry_run: ::std::option::Option<bool>,
     pub(crate) client_token: ::std::option::Option<::std::string::String>,
     pub(crate) source_capacity_reservation_id: ::std::option::Option<::std::string::String>,
     pub(crate) instance_count: ::std::option::Option<i32>,
     pub(crate) tag_specifications: ::std::option::Option<::std::vec::Vec<crate::types::TagSpecification>>,
-221
+}
 impl CreateCapacityReservationBySplittingInputBuilder {
     /// <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
-227
+    }
     /// <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
-232
+    }
     /// <p>Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is <code>DryRunOperation</code>. Otherwise, it is <code>UnauthorizedOperation</code>.</p>
     pub fn get_dry_run(&self) -> &::std::option::Option<bool> {

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

@@ -11,11 +143,194 @@

↥ Expand context

     pub instance_count: ::std::option::Option<i32>,
     _request_id: Option<String>,
-13
+}
 impl CreateCapacityReservationBySplittingOutput {
     /// <p>Information about the source Capacity Reservation.</p>
     pub fn source_capacity_reservation(&self) -> ::std::option::Option<&crate::types::CapacityReservation> {
         self.source_capacity_reservation.as_ref()
-18
+    }
     /// <p>Information about the destination Capacity Reservation.</p>
     pub fn destination_capacity_reservation(&self) -> ::std::option::Option<&crate::types::CapacityReservation> {
         self.destination_capacity_reservation.as_ref()
-22
+    }
     /// <p>The number of instances in the new Capacity Reservation. The number of instances in the source Capacity Reservation was reduced by this amount.</p>
     pub fn instance_count(&self) -> ::std::option::Option<i32> {
         self.instance_count
-26
+    }
-27
+}
 static CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateCapacityReservationBySplittingOutput",
     "com.amazonaws.ec2.synthetic",

     "CreateCapacityReservationBySplittingOutput",
 );
 static CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_MEMBER_SOURCE_CAPACITY_RESERVATION: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#CreateCapacityReservationBySplittingOutput$SourceCapacityReservation",
             "com.amazonaws.ec2.synthetic",
             "CreateCapacityReservationBySplittingOutput",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "source_capacity_reservation",
         "SourceCapacityReservation",
 ,
-43
+    )
     .with_xml_name("sourceCapacityReservation");
 static CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_MEMBER_DESTINATION_CAPACITY_RESERVATION: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#CreateCapacityReservationBySplittingOutput$DestinationCapacityReservation",
             "com.amazonaws.ec2.synthetic",
             "CreateCapacityReservationBySplittingOutput",
         ),
         ::aws_smithy_schema::ShapeType::Structure,
         "destination_capacity_reservation",
         "DestinationCapacityReservation",
 ,
-55
+    )
     .with_xml_name("destinationCapacityReservation");
 static CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_MEMBER_INSTANCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationBySplittingOutput$InstanceCount",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationBySplittingOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "instance_count",
     "InstanceCount",
 ,
-66
+)
 .with_xml_name("instanceCount");
 static CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_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 CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_MEMBER_SOURCE_CAPACITY_RESERVATION,
         &CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_MEMBER_DESTINATION_CAPACITY_RESERVATION,
         &CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_MEMBER_INSTANCE_COUNT,
         &CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl CreateCapacityReservationBySplittingOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_SCHEMA;
-88
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateCapacityReservationBySplittingOutput {
     #[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.source_capacity_reservation {
             ser.write_struct(&CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_MEMBER_SOURCE_CAPACITY_RESERVATION, val)?;
-97
+        }
         if let Some(ref val) = self.destination_capacity_reservation {
             ser.write_struct(&CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_MEMBER_DESTINATION_CAPACITY_RESERVATION, val)?;
-100
+        }
         if let Some(ref val) = self.instance_count {
             ser.write_integer(&CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_MEMBER_INSTANCE_COUNT, *val)?;
-103
+        }
         Ok(())
-105
+    }
-106
+}
 impl CreateCapacityReservationBySplittingOutput {
     /// 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(&CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.source_capacity_reservation = Some(crate::types::CapacityReservation::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder.destination_capacity_reservation = Some(crate::types::CapacityReservation::deserialize(deser)?);
-+
+                }
                 Some(2) => {
                     builder.instance_count = Some(deser.read_integer(member)?);
-+
+                }
                 Some(3) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateCapacityReservationBySplittingOutput {
     /// 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(&CREATECAPACITYRESERVATIONBYSPLITTINGOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.source_capacity_reservation = Some(crate::types::CapacityReservation::deserialize(deser)?);
-168
+                }
                 Some(1) => {
                     builder.destination_capacity_reservation = Some(crate::types::CapacityReservation::deserialize(deser)?);
-171
+                }
                 Some(2) => {
                     builder.instance_count = Some(deser.read_integer(member)?);
-174
+                }

↧ Expand context

                 _ => {}
-176
+            }
             Ok(())
         })?;
         Ok(builder.build())
-180
+    }
-181
+}
 impl ::aws_types::request_id::RequestId for CreateCapacityReservationBySplittingOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-185
+    }
-186
+}
 impl CreateCapacityReservationBySplittingOutput {
     /// Creates a new builder-style object to manufacture [`CreateCapacityReservationBySplittingOutput`](crate::operation::create_capacity_reservation_by_splitting::CreateCapacityReservationBySplittingOutput).
     pub fn builder() -> crate::operation::create_capacity_reservation_by_splitting::builders::CreateCapacityReservationBySplittingOutputBuilder {
         crate::operation::create_capacity_reservation_by_splitting::builders::CreateCapacityReservationBySplittingOutputBuilder::default()
-191
+    }
-192
+}
-193
 /// A builder for [`CreateCapacityReservationBySplittingOutput`](crate::operation::create_capacity_reservation_by_splitting::CreateCapacityReservationBySplittingOutput).

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

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

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

↧ Expand context

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

@@ -135,141 +194,201 @@

↥ Expand context

-141
+    }
-142
     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("CreateCapacityReservationFleet")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateCapacityReservationFleetEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_capacity_reservation_fleet::CreateCapacityReservationFleetError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_capacity_reservation_fleet::CreateCapacityReservationFleetError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::create_capacity_reservation_fleet::CreateCapacityReservationFleetError,
             >::new());
-160

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

↧ Expand context

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

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

@@ -67,67 +210,210 @@

↥ Expand context

         self.end_date.as_ref()
-68
+    }
     /// <p>Indicates the type of instance launches that the Capacity Reservation Fleet accepts. All Capacity Reservations in the Fleet inherit this instance matching criteria.</p>
     /// <p>Currently, Capacity Reservation Fleets support <code>open</code> instance matching criteria only. This means that instances that have matching attributes (instance type, platform, and Availability Zone) run in the Capacity Reservations automatically. Instances do not need to explicitly target a Capacity Reservation Fleet to use its reserved capacity.</p>
     pub fn instance_match_criteria(&self) -> ::std::option::Option<&crate::types::FleetInstanceMatchCriteria> {
         self.instance_match_criteria.as_ref()
-73
+    }
     /// <p>The tags to assign to the Capacity Reservation Fleet. The tags are automatically assigned to the Capacity Reservations in the Fleet.</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()
-79
+    }
     /// <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
-83
+    }
-84
+}
 static CREATECAPACITYRESERVATIONFLEETINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetInput",

     "com.amazonaws.ec2.synthetic",
     "CreateCapacityReservationFleetInput",
 );
 static CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_ALLOCATION_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetInput$AllocationStrategy",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "allocation_strategy",
     "AllocationStrategy",
 ,
 );
 static CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetInput$ClientToken",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_token",
     "ClientToken",
 ,
 );
 static CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_INSTANCE_TYPE_SPECIFICATIONS: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetInput$InstanceTypeSpecifications",
             "com.amazonaws.ec2.synthetic",
             "CreateCapacityReservationFleetInput",
         ),
         ::aws_smithy_schema::ShapeType::List,
         "instance_type_specifications",
         "InstanceTypeSpecifications",
 ,
-120
+    )
     .with_xml_name("InstanceTypeSpecification");
 static CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_TENANCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetInput$Tenancy",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "tenancy",
     "Tenancy",
 ,
 );
 static CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_TOTAL_TARGET_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetInput$TotalTargetCapacity",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "total_target_capacity",
     "TotalTargetCapacity",
 ,
 );
 static CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetInput$EndDate",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "end_date",
     "EndDate",
 ,
 );
 static CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_INSTANCE_MATCH_CRITERIA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetInput$InstanceMatchCriteria",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_match_criteria",
     "InstanceMatchCriteria",
 ,
 );
 static CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetInput$TagSpecifications",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_specifications",
     "TagSpecifications",
 ,
-171
+)
 .with_xml_name("TagSpecification");
 static CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetInput$DryRun",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "dry_run",
     "DryRun",
 ,
 );
 static CREATECAPACITYRESERVATIONFLEETINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATECAPACITYRESERVATIONFLEETINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_ALLOCATION_STRATEGY,
         &CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_CLIENT_TOKEN,
         &CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_INSTANCE_TYPE_SPECIFICATIONS,
         &CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_TENANCY,

↧ Expand context

         &CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_TOTAL_TARGET_CAPACITY,
         &CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_END_DATE,
         &CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_INSTANCE_MATCH_CRITERIA,
         &CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_TAG_SPECIFICATIONS,
         &CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_DRY_RUN,
     ],
 );
 impl CreateCapacityReservationFleetInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATECAPACITYRESERVATIONFLEETINPUT_SCHEMA;
-201
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateCapacityReservationFleetInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.allocation_strategy {
             ser.write_string(&CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_ALLOCATION_STRATEGY, val)?;
-210
+        }

@@ -226,226 +355,362 @@

↥ Expand context

             ser.write_string(&CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_TENANCY, val.as_str())?;
-227
+        }
         if let Some(ref val) = self.total_target_capacity {
             ser.write_integer(&CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_TOTAL_TARGET_CAPACITY, *val)?;
-230
+        }
         if let Some(ref val) = self.end_date {
             ser.write_timestamp(&CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_END_DATE, val)?;
-233
+        }
         if let Some(ref val) = self.instance_match_criteria {
             ser.write_string(&CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_INSTANCE_MATCH_CRITERIA, val.as_str())?;
-236
+        }
         if let Some(ref val) = self.tag_specifications {
             ser.write_list(
                 &CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_TAG_SPECIFICATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
-243
+                    }
                     Ok(())
                 },

             )?;
-247
+        }
         if let Some(ref val) = self.dry_run {
             ser.write_boolean(&CREATECAPACITYRESERVATIONFLEETINPUT_MEMBER_DRY_RUN, *val)?;
-250
+        }
         Ok(())
-252
+    }
-253
+}
 impl CreateCapacityReservationFleetInput {
     /// 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(&CREATECAPACITYRESERVATIONFLEETINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATECAPACITYRESERVATIONFLEETINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.allocation_strategy = Some(deser.read_string(member)?);
-272
+                }
                 Some(1) => {
                     builder.client_token = Some(deser.read_string(member)?);
-275
+                }
                 Some(2) => {
                     builder.instance_type_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::ReservationFleetInstanceSpecification::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ReservationFleetInstanceSpecification::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-285
+                }
                 Some(3) => {
                     builder.tenancy = Some(crate::types::FleetCapacityReservationTenancy::from(deser.read_string(member)?.as_str()));
-288
+                }
                 Some(4) => {
                     builder.total_target_capacity = Some(deser.read_integer(member)?);
-291
+                }
                 Some(5) => {
                     builder.end_date = Some(deser.read_timestamp(member)?);
-294
+                }
                 Some(6) => {
                     builder.instance_match_criteria = Some(crate::types::FleetInstanceMatchCriteria::from(deser.read_string(member)?.as_str()));
-297
+                }
                 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
                     });
-307
+                }
                 Some(8) => {
                     builder.dry_run = Some(deser.read_boolean(member)?);
-310
+                }
                 _ => {}
-312
+            }
             Ok(())
         })?;
         builder.instance_type_specifications = builder.instance_type_specifications.or(Some(Vec::new()));
         builder.total_target_capacity = builder.total_target_capacity.or(Some(0i32));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-320
+    }
-321
+}
 impl CreateCapacityReservationFleetInput {
     /// 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 CreateCapacityReservationFleetInput {
     /// Creates a new builder-style object to manufacture [`CreateCapacityReservationFleetInput`](crate::operation::create_capacity_reservation_fleet::CreateCapacityReservationFleetInput).
     pub fn builder() -> crate::operation::create_capacity_reservation_fleet::builders::CreateCapacityReservationFleetInputBuilder {
         crate::operation::create_capacity_reservation_fleet::builders::CreateCapacityReservationFleetInputBuilder::default()
-337
+    }
-338
+}
-339
 /// A builder for [`CreateCapacityReservationFleetInput`](crate::operation::create_capacity_reservation_fleet::CreateCapacityReservationFleetInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CreateCapacityReservationFleetInputBuilder {
     pub(crate) allocation_strategy: ::std::option::Option<::std::string::String>,
     pub(crate) client_token: ::std::option::Option<::std::string::String>,
     pub(crate) instance_type_specifications: ::std::option::Option<::std::vec::Vec<crate::types::ReservationFleetInstanceSpecification>>,
     pub(crate) tenancy: ::std::option::Option<crate::types::FleetCapacityReservationTenancy>,
     pub(crate) total_target_capacity: ::std::option::Option<i32>,
     pub(crate) end_date: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) instance_match_criteria: ::std::option::Option<crate::types::FleetInstanceMatchCriteria>,
     pub(crate) tag_specifications: ::std::option::Option<::std::vec::Vec<crate::types::TagSpecification>>,
     pub(crate) dry_run: ::std::option::Option<bool>,
-353
+}
 impl CreateCapacityReservationFleetInputBuilder {
     /// <p>The strategy used by the Capacity Reservation Fleet to determine which of the specified instance types to use. Currently, only the <code>prioritized</code> allocation strategy is supported. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#allocation-strategy"> Allocation strategy</a> in the <i>Amazon EC2 User Guide</i>.</p>
     /// <p>Valid values: <code>prioritized</code></p>
     pub fn allocation_strategy(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.allocation_strategy = ::std::option::Option::Some(input.into());
         self
-360
+    }
     /// <p>The strategy used by the Capacity Reservation Fleet to determine which of the specified instance types to use. Currently, only the <code>prioritized</code> allocation strategy is supported. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#allocation-strategy"> Allocation strategy</a> in the <i>Amazon EC2 User Guide</i>.</p>
     /// <p>Valid values: <code>prioritized</code></p>

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

@@ -63,63 +252,260 @@

↥ Expand context

     /// <p>Indicates the tenancy of Capacity Reservation Fleet.</p>
     pub fn tenancy(&self) -> ::std::option::Option<&crate::types::FleetCapacityReservationTenancy> {
         self.tenancy.as_ref()
-66
+    }
     /// <p>Information about the individual Capacity Reservations in the Capacity Reservation Fleet.</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 `.fleet_capacity_reservations.is_none()`.
     pub fn fleet_capacity_reservations(&self) -> &[crate::types::FleetCapacityReservation] {
         self.fleet_capacity_reservations.as_deref().unwrap_or_default()
-72
+    }
     /// <p>The tags assigned to the Capacity Reservation Fleet.</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()
-78
+    }
-79
+}
 static CREATECAPACITYRESERVATIONFLEETOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetOutput",
     "com.amazonaws.ec2.synthetic",

     "CreateCapacityReservationFleetOutput",
 );
 static CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_CAPACITY_RESERVATION_FLEET_ID: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetOutput$CapacityReservationFleetId",
             "com.amazonaws.ec2.synthetic",
             "CreateCapacityReservationFleetOutput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "capacity_reservation_fleet_id",
         "CapacityReservationFleetId",
 ,
-95
+    )
     .with_xml_name("capacityReservationFleetId");
 static CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetOutput$State",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "state",
     "State",
 ,
-106
+)
 .with_xml_name("state");
 static CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_TOTAL_TARGET_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetOutput$TotalTargetCapacity",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "total_target_capacity",
     "TotalTargetCapacity",
 ,
-117
+)
 .with_xml_name("totalTargetCapacity");
 static CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_TOTAL_FULFILLED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetOutput$TotalFulfilledCapacity",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetOutput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "total_fulfilled_capacity",
     "TotalFulfilledCapacity",
 ,
-128
+)
 .with_xml_name("totalFulfilledCapacity");
 static CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_INSTANCE_MATCH_CRITERIA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetOutput$InstanceMatchCriteria",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "instance_match_criteria",
     "InstanceMatchCriteria",
 ,
-139
+)
 .with_xml_name("instanceMatchCriteria");
 static CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_ALLOCATION_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetOutput$AllocationStrategy",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "allocation_strategy",
     "AllocationStrategy",
 ,
-150
+)
 .with_xml_name("allocationStrategy");
 static CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_CREATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetOutput$CreateTime",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "create_time",
     "CreateTime",
 ,
-161
+)
 .with_xml_name("createTime");
 static CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetOutput$EndDate",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "end_date",
     "EndDate",
 ,
-172
+)
 .with_xml_name("endDate");
 static CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_TENANCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetOutput$Tenancy",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "tenancy",
     "Tenancy",
 ,
-183
+)
 .with_xml_name("tenancy");
 static CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_FLEET_CAPACITY_RESERVATIONS: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetOutput$FleetCapacityReservations",
             "com.amazonaws.ec2.synthetic",
             "CreateCapacityReservationFleetOutput",
         ),
         ::aws_smithy_schema::ShapeType::List,
         "fleet_capacity_reservations",
         "FleetCapacityReservations",
 ,
-195
+    )
     .with_xml_name("fleetCapacityReservationSet");
 static CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ec2.synthetic#CreateCapacityReservationFleetOutput$Tags",
         "com.amazonaws.ec2.synthetic",
         "CreateCapacityReservationFleetOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
-206
+)
 .with_xml_name("tagSet");
 static CREATECAPACITYRESERVATIONFLEETOUTPUT_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 CREATECAPACITYRESERVATIONFLEETOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATECAPACITYRESERVATIONFLEETOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_CAPACITY_RESERVATION_FLEET_ID,
         &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_STATE,
         &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_TOTAL_TARGET_CAPACITY,
         &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_TOTAL_FULFILLED_CAPACITY,
         &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_INSTANCE_MATCH_CRITERIA,
         &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_ALLOCATION_STRATEGY,
         &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_CREATE_TIME,
         &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_END_DATE,
         &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_TENANCY,
         &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_FLEET_CAPACITY_RESERVATIONS,
         &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_TAGS,
         &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl CreateCapacityReservationFleetOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATECAPACITYRESERVATIONFLEETOUTPUT_SCHEMA;
-236
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateCapacityReservationFleetOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,

↧ Expand context

         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.capacity_reservation_fleet_id {
             ser.write_string(&CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_CAPACITY_RESERVATION_FLEET_ID, val)?;
-245
+        }
         if let Some(ref val) = self.state {
             ser.write_string(&CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_STATE, val.as_str())?;
-248
+        }
         if let Some(ref val) = self.total_target_capacity {
             ser.write_integer(&CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_TOTAL_TARGET_CAPACITY, *val)?;
-251
+        }
         if let Some(ref val) = self.total_fulfilled_capacity {
             ser.write_double(&CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_TOTAL_FULFILLED_CAPACITY, *val)?;
-254
+        }
         if let Some(ref val) = self.instance_match_criteria {
             ser.write_string(&CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_INSTANCE_MATCH_CRITERIA, val.as_str())?;
-257
+        }
         if let Some(ref val) = self.allocation_strategy {
             ser.write_string(&CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_ALLOCATION_STRATEGY, val)?;
-260
+        }

@@ -259,267 +383,466 @@

↥ Expand context

         if let Some(ref val) = self.tenancy {
             ser.write_string(&CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_TENANCY, val.as_str())?;
-269
+        }
         if let Some(ref val) = self.fleet_capacity_reservations {
             ser.write_list(
                 &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_FLEET_CAPACITY_RESERVATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::FleetCapacityReservation::SCHEMA, item)?;
-276
+                    }
                     Ok(())
                 },
             )?;
-280
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &CREATECAPACITYRESERVATIONFLEETOUTPUT_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;

-287
+                    }
                     Ok(())
                 },
             )?;
-291
+        }
         Ok(())
-293
+    }
-294
+}
 impl CreateCapacityReservationFleetOutput {
     /// 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(&CREATECAPACITYRESERVATIONFLEETOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.capacity_reservation_fleet_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.state = Some(crate::types::CapacityReservationFleetState::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(2) => {
                     builder.total_target_capacity = Some(deser.read_integer(member)?);
-+
+                }
                 Some(3) => {
                     builder.total_fulfilled_capacity = Some(deser.read_double(member)?);
-+
+                }
                 Some(4) => {
                     builder.instance_match_criteria = Some(crate::types::FleetInstanceMatchCriteria::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(5) => {
                     builder.allocation_strategy = Some(deser.read_string(member)?);
-+
+                }
                 Some(6) => {
                     builder.create_time = Some(deser.read_timestamp(member)?);
-+
+                }
                 Some(7) => {
                     builder.end_date = Some(deser.read_timestamp(member)?);
-+
+                }
                 Some(8) => {
                     builder.tenancy = Some(crate::types::FleetCapacityReservationTenancy::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(9) => {
                     builder.fleet_capacity_reservations = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::FleetCapacityReservation::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(10) => {
                     builder.tags = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(11) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateCapacityReservationFleetOutput {
     /// 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(&CREATECAPACITYRESERVATIONFLEETOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATECAPACITYRESERVATIONFLEETOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.capacity_reservation_fleet_id = Some(deser.read_string(member)?);
-394
+                }
                 Some(1) => {
                     builder.state = Some(crate::types::CapacityReservationFleetState::from(deser.read_string(member)?.as_str()));
-397
+                }
                 Some(2) => {
                     builder.total_target_capacity = Some(deser.read_integer(member)?);
-400
+                }
                 Some(3) => {
                     builder.total_fulfilled_capacity = Some(deser.read_double(member)?);
-403
+                }
                 Some(4) => {
                     builder.instance_match_criteria = Some(crate::types::FleetInstanceMatchCriteria::from(deser.read_string(member)?.as_str()));
-406
+                }
                 Some(5) => {
                     builder.allocation_strategy = Some(deser.read_string(member)?);
-409
+                }
                 Some(6) => {
                     builder.create_time = Some(deser.read_timestamp(member)?);
-412
+                }
                 Some(7) => {
                     builder.end_date = Some(deser.read_timestamp(member)?);
-415
+                }
                 Some(8) => {
                     builder.tenancy = Some(crate::types::FleetCapacityReservationTenancy::from(deser.read_string(member)?.as_str()));
-418
+                }
                 Some(9) => {
                     builder.fleet_capacity_reservations = 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::FleetCapacityReservation::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::FleetCapacityReservation::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-428
+                }
                 Some(10) => {
                     builder.tags = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Tag::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-438
+                }
                 _ => {}
-440
+            }
             Ok(())
         })?;
         Ok(builder.build())
-444
+    }
-445
+}
 impl ::aws_types::request_id::RequestId for CreateCapacityReservationFleetOutput {

↧ Expand context

     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-449
+    }
-450
+}
 impl CreateCapacityReservationFleetOutput {
     /// Creates a new builder-style object to manufacture [`CreateCapacityReservationFleetOutput`](crate::operation::create_capacity_reservation_fleet::CreateCapacityReservationFleetOutput).
     pub fn builder() -> crate::operation::create_capacity_reservation_fleet::builders::CreateCapacityReservationFleetOutputBuilder {
         crate::operation::create_capacity_reservation_fleet::builders::CreateCapacityReservationFleetOutputBuilder::default()
-455
+    }
-456
+}
-457
 /// A builder for [`CreateCapacityReservationFleetOutput`](crate::operation::create_capacity_reservation_fleet::CreateCapacityReservationFleetOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CreateCapacityReservationFleetOutputBuilder {
     pub(crate) capacity_reservation_fleet_id: ::std::option::Option<::std::string::String>,
     pub(crate) state: ::std::option::Option<crate::types::CapacityReservationFleetState>,
     pub(crate) total_target_capacity: ::std::option::Option<i32>,
     pub(crate) total_fulfilled_capacity: ::std::option::Option<f64>,
     pub(crate) instance_match_criteria: ::std::option::Option<crate::types::FleetInstanceMatchCriteria>,

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

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

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

↧ Expand context

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

@@ -128,132 +187,192 @@

↥ Expand context

-132
+    }
-133
     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("CreateCarrierGateway")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CreateCarrierGatewayEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_carrier_gateway::CreateCarrierGatewayError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_carrier_gateway::CreateCarrierGatewayError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::create_carrier_gateway::CreateCarrierGatewayError,
             >::new());
-151

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

↧ Expand context

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

AWS SDK

Files changed: