Client Test

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/complete_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 `CompleteSnapshot`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CompleteSnapshot;
 impl CompleteSnapshot {
     /// Creates a new `CompleteSnapshot`
     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::complete_snapshot::CompleteSnapshotInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::complete_snapshot::CompleteSnapshotOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::complete_snapshot::CompleteSnapshotInput,
     ) -> ::std::result::Result<
         crate::operation::complete_snapshot::CompleteSnapshotOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::complete_snapshot::CompleteSnapshotError,
             ::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::complete_snapshot::CompleteSnapshotError>()
                     .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::complete_snapshot::CompleteSnapshotOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -101,105 +231,433 @@

↥ Expand context

                 .expect("required fields set"),
         ));
-107
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("CompleteSnapshot", "EBS"));
-109
         ::std::option::Option::Some(cfg.freeze())
-111
+    }
-112
     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("CompleteSnapshot")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CompleteSnapshotEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::complete_snapshot::CompleteSnapshotError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::complete_snapshot::CompleteSnapshotError,
             >::new());
-127
         ::std::borrow::Cow::Owned(rcb)
-129
+    }
-130
+}
-131
 #[derive(Debug)]
 struct CompleteSnapshotResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CompleteSnapshotResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 202 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-151
         let parse_result = if !success && status != 202 || force_error {
             crate::protocol_serde::shape_complete_snapshot::de_complete_snapshot_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_complete_snapshot::de_complete_snapshot_http_response(status, headers, body)
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled(
                             generic,
                         )),
                     ))
-+
+                }
             };
         crate::protocol_serde::type_erase_result(parse_result)
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "AccessDeniedException" => crate::operation::complete_snapshot::CompleteSnapshotError::AccessDeniedError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::AccessDeniedError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::AccessDeniedError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InternalServerException" => crate::operation::complete_snapshot::CompleteSnapshotError::InternalServerError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InternalServerError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InternalServerError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "RequestThrottledException" => crate::operation::complete_snapshot::CompleteSnapshotError::RequestThrottledError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::RequestThrottledError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::RequestThrottledError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceNotFoundException" => crate::operation::complete_snapshot::CompleteSnapshotError::ResourceNotFoundError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ServiceQuotaExceededException" => crate::operation::complete_snapshot::CompleteSnapshotError::ServiceQuotaExceededError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceQuotaExceededError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceQuotaExceededError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ValidationException" => crate::operation::complete_snapshot::CompleteSnapshotError::ValidationError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ValidationError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ValidationError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::complete_snapshot::CompleteSnapshotError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, CompleteSnapshot::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::complete_snapshot::CompleteSnapshotOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-338
+    }
-339
+}
 #[derive(Debug)]
 struct CompleteSnapshotRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CompleteSnapshotRequestSerializer {
     #[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::complete_snapshot::CompleteSnapshotInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::complete_snapshot::CompleteSnapshotInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.snapshot_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("snapshot_id", "cannot be empty or unset"))?;
                 let snapshot_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if snapshot_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "snapshot_id",
                         "cannot be empty or unset",
                     ));
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, CompleteSnapshot::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/snapshots/completion/{SnapshotId}".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.changed_blocks_count {
                     request.headers_mut().insert("x-amz-ChangedBlocksCount", val.to_string());
-+
+                }
                 if let Some(ref val) = input.checksum_aggregation_method {
                     request
                         .headers_mut()
                         .insert("x-amz-Checksum-Aggregation-Method", val.as_str().to_string());
-+
+                }
                 if let Some(ref val) = input.checksum_algorithm {
                     request.headers_mut().insert("x-amz-Checksum-Algorithm", val.as_str().to_string());
-+
+                }
                 if let Some(ref val) = input.snapshot_id {
                     uri = uri.replace("{SnapshotId}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
-+
+                }
                 if let Some(ref val) = input.checksum {
                     request.headers_mut().insert("x-amz-Checksum", val.to_string());
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-392
+                }
                 ::std::write!(output, "/snapshots/completion/{SnapshotId}", SnapshotId = snapshot_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
                 request.set_uri(uri.as_str()).expect("valid URI");
-394
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::complete_snapshot::CompleteSnapshotInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_complete_snapshot::ser_complete_snapshot_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-395
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, CompleteSnapshot::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-+
+        }
-404
+    }
-405
+}
 #[derive(Debug)]
 struct CompleteSnapshotEndpointParamsInterceptor;
-408
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CompleteSnapshotEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "CompleteSnapshotEndpointParamsInterceptor"
-412
+    }
-413

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<CompleteSnapshotInput>()
             .ok_or("failed to downcast to CompleteSnapshotInput")?;
-428
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/complete_snapshot/_complete_snapshot_input.rs

@@ -23,23 +204,260 @@

↥ Expand context

     /// <p>The aggregation method used to generate the checksum. Currently, the only supported aggregation method is <code>LINEAR</code>.</p>
     pub fn checksum_aggregation_method(&self) -> ::std::option::Option<&crate::types::ChecksumAggregationMethod> {
         self.checksum_aggregation_method.as_ref()
-26
+    }
     /// <p>The algorithm used to generate the checksum. Currently, the only supported algorithm is <code>SHA256</code>.</p>
     pub fn checksum_algorithm(&self) -> ::std::option::Option<&crate::types::ChecksumAlgorithm> {
         self.checksum_algorithm.as_ref()
-30
+    }
     /// <p>The ID of the snapshot.</p>
     pub fn snapshot_id(&self) -> ::std::option::Option<&str> {
         self.snapshot_id.as_deref()
-34
+    }
     /// <p>An aggregated Base-64 SHA256 checksum based on the checksums of each written block.</p>
     /// <p>To generate the aggregated checksum using the linear aggregation method, arrange the checksums for each written block in ascending order of their block index, concatenate them to form a single string, and then generate the checksum on the entire string using the SHA256 algorithm.</p>
     pub fn checksum(&self) -> ::std::option::Option<&str> {
         self.checksum.as_deref()
-39
+    }
-40
+}
 static COMPLETESNAPSHOTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ebs.synthetic#CompleteSnapshotInput",

     "com.amazonaws.ebs.synthetic",
     "CompleteSnapshotInput",
 );
 static COMPLETESNAPSHOTINPUT_MEMBER_CHANGED_BLOCKS_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#CompleteSnapshotInput$ChangedBlocksCount",
         "com.amazonaws.ebs.synthetic",
         "CompleteSnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "changed_blocks_count",
     "ChangedBlocksCount",
 ,
-55
+)
 .with_http_header("x-amz-ChangedBlocksCount");
 static COMPLETESNAPSHOTINPUT_MEMBER_CHECKSUM_AGGREGATION_METHOD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#CompleteSnapshotInput$ChecksumAggregationMethod",
         "com.amazonaws.ebs.synthetic",
         "CompleteSnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_aggregation_method",
     "ChecksumAggregationMethod",
 ,
-66
+)
 .with_http_header("x-amz-Checksum-Aggregation-Method");
 static COMPLETESNAPSHOTINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#CompleteSnapshotInput$ChecksumAlgorithm",
         "com.amazonaws.ebs.synthetic",
         "CompleteSnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-77
+)
 .with_http_header("x-amz-Checksum-Algorithm");
 static COMPLETESNAPSHOTINPUT_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#CompleteSnapshotInput$SnapshotId",
         "com.amazonaws.ebs.synthetic",
         "CompleteSnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "snapshot_id",
     "SnapshotId",
 ,
-88
+)
 .with_http_label();
 static COMPLETESNAPSHOTINPUT_MEMBER_CHECKSUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#CompleteSnapshotInput$Checksum",
         "com.amazonaws.ebs.synthetic",
         "CompleteSnapshotInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum",
     "Checksum",
 ,
-99
+)
 .with_http_header("x-amz-Checksum");
 static COMPLETESNAPSHOTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     COMPLETESNAPSHOTINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &COMPLETESNAPSHOTINPUT_MEMBER_CHANGED_BLOCKS_COUNT,
         &COMPLETESNAPSHOTINPUT_MEMBER_CHECKSUM_AGGREGATION_METHOD,
         &COMPLETESNAPSHOTINPUT_MEMBER_CHECKSUM_ALGORITHM,
         &COMPLETESNAPSHOTINPUT_MEMBER_SNAPSHOT_ID,
         &COMPLETESNAPSHOTINPUT_MEMBER_CHECKSUM,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "POST",
     "/snapshots/completion/{SnapshotId}",
     Some(202),
 ));
 impl CompleteSnapshotInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COMPLETESNAPSHOTINPUT_SCHEMA;
-120
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CompleteSnapshotInput {
     #[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.changed_blocks_count {
             ser.write_integer(&COMPLETESNAPSHOTINPUT_MEMBER_CHANGED_BLOCKS_COUNT, *val)?;
-129
+        }
         if let Some(ref val) = self.checksum_aggregation_method {
             ser.write_string(&COMPLETESNAPSHOTINPUT_MEMBER_CHECKSUM_AGGREGATION_METHOD, val.as_str())?;
-132
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&COMPLETESNAPSHOTINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-135
+        }
         if let Some(ref val) = self.snapshot_id {
             ser.write_string(&COMPLETESNAPSHOTINPUT_MEMBER_SNAPSHOT_ID, val)?;
-138
+        }
         if let Some(ref val) = self.checksum {
             ser.write_string(&COMPLETESNAPSHOTINPUT_MEMBER_CHECKSUM, val)?;
-141
+        }
         Ok(())
-143
+    }
-144
+}
 impl CompleteSnapshotInput {
     /// 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(&COMPLETESNAPSHOTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&COMPLETESNAPSHOTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.changed_blocks_count = Some(deser.read_integer(member)?);
-163
+                }
                 Some(1) => {
                     builder.checksum_aggregation_method = Some(crate::types::ChecksumAggregationMethod::from(deser.read_string(member)?.as_str()));
-166
+                }
                 Some(2) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-169
+                }
                 Some(3) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-172
+                }
                 Some(4) => {
                     builder.checksum = Some(deser.read_string(member)?);
-175
+                }
                 _ => {}
-177
+            }
             Ok(())
         })?;
         builder.changed_blocks_count = builder.changed_blocks_count.or(Some(0i32));
         builder.snapshot_id = builder.snapshot_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl CompleteSnapshotInput {
     /// 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-amz-ChangedBlocksCount") {
             builder.changed_blocks_count = val.parse::<i32>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-Checksum-Aggregation-Method") {
             builder.checksum_aggregation_method = Some(crate::types::ChecksumAggregationMethod::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-Checksum-Algorithm") {
             builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-Checksum") {
             builder.checksum = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&COMPLETESNAPSHOTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => { /* read from headers above */ }
                 Some(2) => { /* read from headers above */ }
                 Some(3) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(4) => { /* read from headers above */ }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-234
+    }
-235
+}
 impl CompleteSnapshotInput {
     /// Creates a new builder-style object to manufacture [`CompleteSnapshotInput`](crate::operation::complete_snapshot::CompleteSnapshotInput).
     pub fn builder() -> crate::operation::complete_snapshot::builders::CompleteSnapshotInputBuilder {
         crate::operation::complete_snapshot::builders::CompleteSnapshotInputBuilder::default()
-240
+    }

↧ Expand context

-241
+}
-242
 /// A builder for [`CompleteSnapshotInput`](crate::operation::complete_snapshot::CompleteSnapshotInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CompleteSnapshotInputBuilder {
     pub(crate) changed_blocks_count: ::std::option::Option<i32>,
     pub(crate) checksum_aggregation_method: ::std::option::Option<crate::types::ChecksumAggregationMethod>,
     pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
     pub(crate) snapshot_id: ::std::option::Option<::std::string::String>,
     pub(crate) checksum: ::std::option::Option<::std::string::String>,
-252
+}
 impl CompleteSnapshotInputBuilder {
     /// <p>The number of blocks that were written to the snapshot.</p>
     /// This field is required.
     pub fn changed_blocks_count(mut self, input: i32) -> Self {
         self.changed_blocks_count = ::std::option::Option::Some(input);
         self
-259
+    }
     /// <p>The number of blocks that were written to the snapshot.</p>

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/complete_snapshot/_complete_snapshot_output.rs

@@ -1,1 +106,117 @@

↥ 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 CompleteSnapshotOutput {
     /// <p>The status of the snapshot.</p>
     pub status: ::std::option::Option<crate::types::Status>,
-8
+}
 impl CompleteSnapshotOutput {
     /// <p>The status of the snapshot.</p>
     pub fn status(&self) -> ::std::option::Option<&crate::types::Status> {
         self.status.as_ref()
-13
+    }
-14
+}
 static COMPLETESNAPSHOTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ebs.synthetic#CompleteSnapshotOutput",

     "com.amazonaws.ebs.synthetic",
     "CompleteSnapshotOutput",
 );
 static COMPLETESNAPSHOTOUTPUT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#CompleteSnapshotOutput$Status",
         "com.amazonaws.ebs.synthetic",
         "CompleteSnapshotOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "status",
     "Status",
 ,
 );
 static COMPLETESNAPSHOTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     COMPLETESNAPSHOTOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&COMPLETESNAPSHOTOUTPUT_MEMBER_STATUS],
 );
 impl CompleteSnapshotOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COMPLETESNAPSHOTOUTPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CompleteSnapshotOutput {
     #[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.status {
             ser.write_string(&COMPLETESNAPSHOTOUTPUT_MEMBER_STATUS, val.as_str())?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl CompleteSnapshotOutput {
     /// 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(&COMPLETESNAPSHOTOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&COMPLETESNAPSHOTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.status = Some(crate::types::Status::from(deser.read_string(member)?.as_str()));
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         Ok(builder.build())
-75
+    }
-76
+}
 impl CompleteSnapshotOutput {
     /// 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 CompleteSnapshotOutput {
     /// Creates a new builder-style object to manufacture [`CompleteSnapshotOutput`](crate::operation::complete_snapshot::CompleteSnapshotOutput).
     pub fn builder() -> crate::operation::complete_snapshot::builders::CompleteSnapshotOutputBuilder {
         crate::operation::complete_snapshot::builders::CompleteSnapshotOutputBuilder::default()
-92
+    }
-93
+}
-94
 /// A builder for [`CompleteSnapshotOutput`](crate::operation::complete_snapshot::CompleteSnapshotOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CompleteSnapshotOutputBuilder {
     pub(crate) status: ::std::option::Option<crate::types::Status>,
-100
+}
 impl CompleteSnapshotOutputBuilder {
     /// <p>The status of the snapshot.</p>
     pub fn status(mut self, input: crate::types::Status) -> Self {
         self.status = ::std::option::Option::Some(input);
         self
-106
+    }
     /// <p>The status of the snapshot.</p>
     pub fn set_status(mut self, input: ::std::option::Option<crate::types::Status>) -> Self {
         self.status = input;
         self
-111
+    }
     /// <p>The status of the snapshot.</p>
     pub fn get_status(&self) -> &::std::option::Option<crate::types::Status> {
         &self.status
-115
+    }
     /// Consumes the builder and constructs a [`CompleteSnapshotOutput`](crate::operation::complete_snapshot::CompleteSnapshotOutput).
     pub fn build(self) -> crate::operation::complete_snapshot::CompleteSnapshotOutput {

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/get_snapshot_block.rs

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

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

↧ Expand context

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

@@ -118,122 +279,418 @@

↥ Expand context

             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_snapshot_block::GetSnapshotBlockError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_snapshot_block::GetSnapshotBlockError,
             >::new());
-128
         ::std::borrow::Cow::Owned(rcb)
-130
+    }
-131
+}
-132
 #[derive(Debug)]
 struct GetSnapshotBlockResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetSnapshotBlockResponseDeserializer {
     fn deserialize_streaming(
         &self,
         response: &mut ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::std::option::Option<::aws_smithy_runtime_api::client::interceptors::context::OutputOrError> {
         #[allow(unused_mut)]
         let mut force_error = false;

-142
         // If this is an error, defer to the non-streaming parser
         if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {
             return ::std::option::Option::None;
-146
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_get_snapshot_block::de_get_snapshot_block_http_response(response),
         ))
-150
+    }
-151
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         // For streaming operations, we only hit this case if its an error
         let body = response.body().bytes().expect("body loaded");
         crate::protocol_serde::type_erase_result(crate::protocol_serde::shape_get_snapshot_block::de_get_snapshot_block_http_error(
             response.status().as_u16(),
         let status = response.status().as_u16();
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
             ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         })?;
-+
         let generic = generic_builder.build();
         let error_code = match generic.code() {
             ::std::option::Option::Some(code) => code,
             ::std::option::Option::None => {
                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                     ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled(
                         generic,
                     )),
                 ))
-+
+            }
         };
         let _error_message = generic.message().map(|msg| msg.to_owned());
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let err = match error_code {
             "AccessDeniedException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::AccessDeniedError({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::AccessDeniedError::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::AccessDeniedError::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "InternalServerException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::InternalServerError({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::InternalServerError::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::InternalServerError::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "RequestThrottledException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::RequestThrottledError({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::RequestThrottledError::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::RequestThrottledError::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "ResourceNotFoundException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::ResourceNotFoundError({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ResourceNotFoundError::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ResourceNotFoundError::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "ServiceQuotaExceededException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::ServiceQuotaExceededError({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ServiceQuotaExceededError::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ServiceQuotaExceededError::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "ValidationException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::ValidationError({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ValidationError::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ValidationError::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             _ => crate::operation::get_snapshot_block::GetSnapshotBlockError::generic(generic),
         };
         ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
             ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         ))
-331
+    }
-332
+}
 #[derive(Debug)]
 struct GetSnapshotBlockRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetSnapshotBlockRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::get_snapshot_block::GetSnapshotBlockInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::get_snapshot_block::GetSnapshotBlockInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.snapshot_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("snapshot_id", "cannot be empty or unset"))?;
                 let snapshot_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if snapshot_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "snapshot_id",
                         "cannot be empty or unset",
                     ));
--
+                }
                 let input_2 = &_input.block_index;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("block_index", "cannot be empty or unset"))?;
                 let mut block_index_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_2);
                 let block_index = block_index_encoder.encode();
                 if block_index.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "block_index",
                         "cannot be empty or unset",
                     ));
--
+                }
                 ::std::write!(
                     output,
                     "/snapshots/{SnapshotId}/blocks/{BlockIndex}",
                     SnapshotId = snapshot_id,
                     BlockIndex = block_index
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, GetSnapshotBlock::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/snapshots/{SnapshotId}/blocks/{BlockIndex}".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.snapshot_id {
                     uri = uri.replace("{SnapshotId}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
-+
+                }
                 if let Some(ref val) = input.block_token {
                     query_params.push(("blockToken".to_string(), val.to_string()));
-+
+                }
                 if let Some(ref val) = input.block_index {
                     uri = uri.replace("{BlockIndex}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-373
+                            )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::get_snapshot_block::GetSnapshotBlockInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 let inner_3 = &_input.block_token;
                 let inner_3 = inner_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("block_token", "cannot be empty or unset"))?;
                 if inner_3.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "block_token",
                         "cannot be empty or unset",
                     ));
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-377
+                }
                 query.push_kv("blockToken", &::aws_smithy_http::query::fmt_string(inner_3));
                 ::std::result::Result::Ok(())
                 request.set_uri(uri.as_str()).expect("valid URI");
-379
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_snapshot_block::GetSnapshotBlockInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-380
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, GetSnapshotBlock::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-+
+        }
-389
+    }
-390
+}
 #[derive(Debug)]
 struct GetSnapshotBlockEndpointParamsInterceptor;
-393
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetSnapshotBlockEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetSnapshotBlockEndpointParamsInterceptor"
-397
+    }
-398

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GetSnapshotBlockInput>()
             .ok_or("failed to downcast to GetSnapshotBlockInput")?;
-413
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/get_snapshot_block/_get_snapshot_block_input.rs

@@ -13,13 +163,182 @@

↥ Expand context

     pub block_index: ::std::option::Option<i32>,
-14
+}
 impl GetSnapshotBlockInput {
     /// <p>The ID of the snapshot containing the block from which to get data.</p>
     pub fn snapshot_id(&self) -> ::std::option::Option<&str> {
         self.snapshot_id.as_deref()
-19
+    }
     /// <p>The block token of the block from which to get data.</p>
     /// <p>Obtain the <code>BlockToken</code> by running the <code>ListChangedBlocks</code> or <code>ListSnapshotBlocks</code> operations.</p>
     pub fn block_token(&self) -> ::std::option::Option<&str> {
         self.block_token.as_deref()
-24
+    }
     /// <p>The block index of the block from which to get data.</p>
     /// <p>Obtain the <code>BlockIndex</code> by running the <code>ListChangedBlocks</code> or <code>ListSnapshotBlocks</code> operations.</p>
     pub fn block_index(&self) -> ::std::option::Option<i32> {
         self.block_index
-29
+    }
-30
+}
 static GETSNAPSHOTBLOCKINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ebs.synthetic#GetSnapshotBlockInput",

     "com.amazonaws.ebs.synthetic",
     "GetSnapshotBlockInput",
 );
 static GETSNAPSHOTBLOCKINPUT_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#GetSnapshotBlockInput$SnapshotId",
         "com.amazonaws.ebs.synthetic",
         "GetSnapshotBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "snapshot_id",
     "SnapshotId",
 ,
-45
+)
 .with_http_label();
 static GETSNAPSHOTBLOCKINPUT_MEMBER_BLOCK_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#GetSnapshotBlockInput$BlockToken",
         "com.amazonaws.ebs.synthetic",
         "GetSnapshotBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "block_token",
     "BlockToken",
 ,
-56
+)
 .with_http_query("blockToken");
 static GETSNAPSHOTBLOCKINPUT_MEMBER_BLOCK_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#GetSnapshotBlockInput$BlockIndex",
         "com.amazonaws.ebs.synthetic",
         "GetSnapshotBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "block_index",
     "BlockIndex",
 ,
-67
+)
 .with_http_label();
 static GETSNAPSHOTBLOCKINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETSNAPSHOTBLOCKINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &GETSNAPSHOTBLOCKINPUT_MEMBER_SNAPSHOT_ID,
         &GETSNAPSHOTBLOCKINPUT_MEMBER_BLOCK_TOKEN,
         &GETSNAPSHOTBLOCKINPUT_MEMBER_BLOCK_INDEX,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "GET",
     "/snapshots/{SnapshotId}/blocks/{BlockIndex}",
     None,
 ));
 impl GetSnapshotBlockInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETSNAPSHOTBLOCKINPUT_SCHEMA;
-86
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetSnapshotBlockInput {
     #[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.snapshot_id {
             ser.write_string(&GETSNAPSHOTBLOCKINPUT_MEMBER_SNAPSHOT_ID, val)?;
-95
+        }
         if let Some(ref val) = self.block_token {
             ser.write_string(&GETSNAPSHOTBLOCKINPUT_MEMBER_BLOCK_TOKEN, val)?;
-98
+        }
         if let Some(ref val) = self.block_index {
             ser.write_integer(&GETSNAPSHOTBLOCKINPUT_MEMBER_BLOCK_INDEX, *val)?;
-101
+        }
         Ok(())
-103
+    }
-104
+}
 impl GetSnapshotBlockInput {
     /// 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(&GETSNAPSHOTBLOCKINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETSNAPSHOTBLOCKINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-123
+                }
                 Some(1) => {
                     builder.block_token = Some(deser.read_string(member)?);
-126
+                }
                 Some(2) => {
                     builder.block_index = Some(deser.read_integer(member)?);
-129
+                }
                 _ => {}
-131
+            }
             Ok(())
         })?;
         builder.snapshot_id = builder.snapshot_id.or(Some(String::new()));
         builder.block_token = builder.block_token.or(Some(String::new()));
         builder.block_index = builder.block_index.or(Some(0i32));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-140
+    }
-141
+}
 impl GetSnapshotBlockInput {
     /// 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 GetSnapshotBlockInput {
     /// Creates a new builder-style object to manufacture [`GetSnapshotBlockInput`](crate::operation::get_snapshot_block::GetSnapshotBlockInput).
     pub fn builder() -> crate::operation::get_snapshot_block::builders::GetSnapshotBlockInputBuilder {
         crate::operation::get_snapshot_block::builders::GetSnapshotBlockInputBuilder::default()
-157
+    }
-158
+}
-159
 /// A builder for [`GetSnapshotBlockInput`](crate::operation::get_snapshot_block::GetSnapshotBlockInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GetSnapshotBlockInputBuilder {
     pub(crate) snapshot_id: ::std::option::Option<::std::string::String>,
     pub(crate) block_token: ::std::option::Option<::std::string::String>,
     pub(crate) block_index: ::std::option::Option<i32>,
-167
+}
 impl GetSnapshotBlockInputBuilder {
     /// <p>The ID of the snapshot containing the block from which to get data.</p>
     /// This field is required.
     pub fn snapshot_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.snapshot_id = ::std::option::Option::Some(input.into());
         self
-174
+    }
     /// <p>The ID of the snapshot containing the block from which to get data.</p>
     pub fn set_snapshot_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.snapshot_id = input;
         self
-179
+    }
     /// <p>The ID of the snapshot containing the block from which to get data.</p>
     pub fn get_snapshot_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.snapshot_id

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/get_snapshot_block/_get_snapshot_block_output.rs

@@ -24,24 +194,236 @@

↥ Expand context

     pub fn checksum(&self) -> ::std::option::Option<&str> {
         self.checksum.as_deref()
-26
+    }
     /// <p>The data content of the block.</p>
     pub fn block_data(&self) -> &::aws_smithy_types::byte_stream::ByteStream {
         &self.block_data
-30
+    }
-31
+}
 impl ::std::fmt::Debug for GetSnapshotBlockOutput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("GetSnapshotBlockOutput");
         formatter.field("data_length", &self.data_length);
         formatter.field("checksum_algorithm", &self.checksum_algorithm);
         formatter.field("checksum", &self.checksum);
         formatter.field("block_data", &"*** Sensitive Data Redacted ***");
         formatter.finish()
-40
+    }
-41
+}
 static GETSNAPSHOTBLOCKOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ebs.synthetic#GetSnapshotBlockOutput",

     "com.amazonaws.ebs.synthetic",
     "GetSnapshotBlockOutput",
 );
 static GETSNAPSHOTBLOCKOUTPUT_MEMBER_DATA_LENGTH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#GetSnapshotBlockOutput$DataLength",
         "com.amazonaws.ebs.synthetic",
         "GetSnapshotBlockOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "data_length",
     "DataLength",
 ,
-56
+)
 .with_http_header("x-amz-Data-Length");
 static GETSNAPSHOTBLOCKOUTPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#GetSnapshotBlockOutput$ChecksumAlgorithm",
         "com.amazonaws.ebs.synthetic",
         "GetSnapshotBlockOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-67
+)
 .with_http_header("x-amz-Checksum-Algorithm");
 static GETSNAPSHOTBLOCKOUTPUT_MEMBER_CHECKSUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#GetSnapshotBlockOutput$Checksum",
         "com.amazonaws.ebs.synthetic",
         "GetSnapshotBlockOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum",
     "Checksum",
 ,
-78
+)
 .with_http_header("x-amz-Checksum");
 static GETSNAPSHOTBLOCKOUTPUT_MEMBER_BLOCK_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#GetSnapshotBlockOutput$BlockData",
         "com.amazonaws.ebs.synthetic",
         "GetSnapshotBlockOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "block_data",
     "BlockData",
 ,
-89
+)
 .with_http_payload();
 static GETSNAPSHOTBLOCKOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETSNAPSHOTBLOCKOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &GETSNAPSHOTBLOCKOUTPUT_MEMBER_DATA_LENGTH,
         &GETSNAPSHOTBLOCKOUTPUT_MEMBER_CHECKSUM_ALGORITHM,
         &GETSNAPSHOTBLOCKOUTPUT_MEMBER_CHECKSUM,
         &GETSNAPSHOTBLOCKOUTPUT_MEMBER_BLOCK_DATA,
     ],
 );
 impl GetSnapshotBlockOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETSNAPSHOTBLOCKOUTPUT_SCHEMA;
-104
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetSnapshotBlockOutput {
     #[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.data_length {
             ser.write_integer(&GETSNAPSHOTBLOCKOUTPUT_MEMBER_DATA_LENGTH, *val)?;
-113
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&GETSNAPSHOTBLOCKOUTPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-116
+        }
         if let Some(ref val) = self.checksum {
             ser.write_string(&GETSNAPSHOTBLOCKOUTPUT_MEMBER_CHECKSUM, val)?;
-119
+        }
--
+        {
             let val = &self.block_data;
             // streaming blob is serialized as the HTTP body by the protocol, not the codec
--
+        }
         Ok(())
-121
+    }
-122
+}
 impl GetSnapshotBlockOutput {
     /// 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(&GETSNAPSHOTBLOCKOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETSNAPSHOTBLOCKOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.data_length = Some(deser.read_integer(member)?);
-141
+                }
                 Some(1) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-144
+                }
                 Some(2) => {
                     builder.checksum = Some(deser.read_string(member)?);
-147
+                }
                 Some(3) => {
                     builder.block_data = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-153
+                }
                 _ => {}
-155
+            }
             Ok(())
         })?;
         Ok(builder.build())
-159
+    }
-160
+}
 impl GetSnapshotBlockOutput {
     /// 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-amz-Data-Length") {
             builder.data_length = val.parse::<i32>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-Checksum-Algorithm") {
             builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-Checksum") {
             builder.checksum = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&GETSNAPSHOTBLOCKOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => { /* read from headers above */ }
                 Some(2) => { /* read from headers above */ }
                 Some(3) => {
                     builder.block_data = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl GetSnapshotBlockOutput {
     /// Creates a new builder-style object to manufacture [`GetSnapshotBlockOutput`](crate::operation::get_snapshot_block::GetSnapshotBlockOutput).
     pub fn builder() -> crate::operation::get_snapshot_block::builders::GetSnapshotBlockOutputBuilder {
         crate::operation::get_snapshot_block::builders::GetSnapshotBlockOutputBuilder::default()
-211
+    }
-212
+}
-213
 /// A builder for [`GetSnapshotBlockOutput`](crate::operation::get_snapshot_block::GetSnapshotBlockOutput).
 #[derive(::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct GetSnapshotBlockOutputBuilder {
     pub(crate) data_length: ::std::option::Option<i32>,
     pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
     pub(crate) checksum: ::std::option::Option<::std::string::String>,
     pub(crate) block_data: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>,
-222
+}
 impl GetSnapshotBlockOutputBuilder {
     /// <p>The size of the data in the block.</p>
     pub fn data_length(mut self, input: i32) -> Self {
         self.data_length = ::std::option::Option::Some(input);
         self
-228
+    }
     /// <p>The size of the data in the block.</p>
     pub fn set_data_length(mut self, input: ::std::option::Option<i32>) -> Self {
         self.data_length = input;
         self
-233
+    }
     /// <p>The size of the data in the block.</p>
     pub fn get_data_length(&self) -> &::std::option::Option<i32> {
         &self.data_length

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/list_changed_blocks.rs

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

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

@@ -102,106 +264,435 @@

↥ Expand context

         ));
-107
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::SensitiveOutput);
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("ListChangedBlocks", "EBS"));
-110
         ::std::option::Option::Some(cfg.freeze())
-112
+    }
-113
     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("ListChangedBlocks")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListChangedBlocksEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_changed_blocks::ListChangedBlocksError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::list_changed_blocks::ListChangedBlocksError,
             >::new());
-128
         ::std::borrow::Cow::Owned(rcb)
-130
+    }
-131
+}
-132
 #[derive(Debug)]
 struct ListChangedBlocksResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListChangedBlocksResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-152
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_list_changed_blocks::de_list_changed_blocks_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_list_changed_blocks::de_list_changed_blocks_http_response(status, headers, body)
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "AccessDeniedException" => crate::operation::list_changed_blocks::ListChangedBlocksError::AccessDeniedError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::AccessDeniedError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::AccessDeniedError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InternalServerException" => crate::operation::list_changed_blocks::ListChangedBlocksError::InternalServerError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InternalServerError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InternalServerError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "RequestThrottledException" => crate::operation::list_changed_blocks::ListChangedBlocksError::RequestThrottledError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::RequestThrottledError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::RequestThrottledError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceNotFoundException" => crate::operation::list_changed_blocks::ListChangedBlocksError::ResourceNotFoundError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ServiceQuotaExceededException" => crate::operation::list_changed_blocks::ListChangedBlocksError::ServiceQuotaExceededError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceQuotaExceededError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceQuotaExceededError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ValidationException" => crate::operation::list_changed_blocks::ListChangedBlocksError::ValidationError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ValidationError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ValidationError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::list_changed_blocks::ListChangedBlocksError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, ListChangedBlocks::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::list_changed_blocks::ListChangedBlocksOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-339
+    }
-340
+}
 #[derive(Debug)]
 struct ListChangedBlocksRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListChangedBlocksRequestSerializer {
     #[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::list_changed_blocks::ListChangedBlocksInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_changed_blocks::ListChangedBlocksInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.second_snapshot_id;
                 let input_1 = input_1.as_ref().ok_or_else(|| {
                     ::aws_smithy_types::error::operation::BuildError::missing_field("second_snapshot_id", "cannot be empty or unset")
                 })?;
                 let second_snapshot_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if second_snapshot_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "second_snapshot_id",
                         "cannot be empty or unset",
                     ));
--
+                }
                 ::std::write!(
                     output,
                     "/snapshots/{SecondSnapshotId}/changedblocks",
                     SecondSnapshotId = second_snapshot_id
--
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::list_changed_blocks::ListChangedBlocksInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_2) = &_input.first_snapshot_id {
--
+                    {
                         query.push_kv("firstSnapshotId", &::aws_smithy_http::query::fmt_string(inner_2));
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.next_token {
--
+                    {
                         query.push_kv("pageToken", &::aws_smithy_http::query::fmt_string(inner_3));
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.max_results {
--
+                    {
                         query.push_kv("maxResults", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_5) = &_input.starting_block_index {
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, ListChangedBlocks::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-360
+            {
                         query.push_kv("startingBlockIndex", ::aws_smithy_types::primitive::Encoder::from(*inner_5).encode());
--
+                    }
                 let mut uri = "/snapshots/{SecondSnapshotId}/changedblocks".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.second_snapshot_id {
                     uri = uri.replace(
                         "{SecondSnapshotId}",
                         &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()),
                     );
-+
+                }
                 if let Some(ref val) = input.first_snapshot_id {
                     query_params.push(("firstSnapshotId".to_string(), val.to_string()));
-+
+                }
                 if let Some(ref val) = input.next_token {
                     query_params.push(("pageToken".to_string(), val.to_string()));
-+
+                }
                 if let Some(ref val) = input.max_results {
                     query_params.push(("maxResults".to_string(), val.to_string()));
-+
+                }
                 if let Some(ref val) = input.starting_block_index {
                     query_params.push(("startingBlockIndex".to_string(), val.to_string()));
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-394
+                }
                 ::std::result::Result::Ok(())
                 request.set_uri(uri.as_str()).expect("valid URI");
-396
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_changed_blocks::ListChangedBlocksInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-397
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, ListChangedBlocks::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-+
+        }
-406
+    }
-407
+}
 #[derive(Debug)]
 struct ListChangedBlocksEndpointParamsInterceptor;
-410
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListChangedBlocksEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListChangedBlocksEndpointParamsInterceptor"
-414
+    }
-415

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListChangedBlocksInput>()
             .ok_or("failed to downcast to ListChangedBlocksInput")?;
-430
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

 pub mod client;
-121
 /// Configuration for Amazon Elastic Block Store.
 pub mod config;
-124
 /// Common errors and error handling utilities.
 pub mod error;
-127
 mod error_meta;
-129
 /// Information about this crate.
 pub mod meta;
-132
 /// Primitives such as `Blob` or `DateTime` used by other types.
 pub mod primitives;
-135
 /// Data structures used by operation inputs/outputs.
 pub mod types;
-138
 pub(crate) mod client_idempotency_token;

-140
 mod idempotency_token;
-142
 /// All operations that this crate can perform.
 pub mod operation;
-145
 pub(crate) mod protocol_serde;
-147
 mod sdk_feature_tracker;
-149
 mod serialization_settings;
 mod json_errors;
-151
 mod lens;
-153
 mod serde_util;
--
 mod json_errors;
--
 pub use client::Client;

Client Test

Files changed:

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/lib.rs

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/complete_snapshot.rs

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/complete_snapshot/_complete_snapshot_input.rs

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/complete_snapshot/_complete_snapshot_output.rs

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/get_snapshot_block.rs

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/get_snapshot_block/_get_snapshot_block_input.rs

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/get_snapshot_block/_get_snapshot_block_output.rs

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/list_changed_blocks.rs