Client Test

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/document_type_as_payload.rs

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

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

@@ -110,114 +234,250 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "DocumentTypeAsPayload",
             "Rest Json Protocol",
         ));
-118
         ::std::option::Option::Some(cfg.freeze())
-120
+    }
-121
     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("DocumentTypeAsPayload")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DocumentTypeAsPayloadEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::document_type_as_payload::DocumentTypeAsPayloadError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::document_type_as_payload::DocumentTypeAsPayloadError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct DocumentTypeAsPayloadResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DocumentTypeAsPayloadResponseDeserializer {
     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))
             })?;
-160
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_document_type_as_payload::de_document_type_as_payload_http_error(status, headers, body)
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::document_type_as_payload::DocumentTypeAsPayloadError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_document_type_as_payload::de_document_type_as_payload_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, DocumentTypeAsPayload::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::document_type_as_payload::DocumentTypeAsPayloadOutput::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))
-+
+        }
-188
+    }
-189
+}
 #[derive(Debug)]
 struct DocumentTypeAsPayloadRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DocumentTypeAsPayloadRequestSerializer {
     #[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::document_type_as_payload::DocumentTypeAsPayloadInput>()
             .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::document_type_as_payload::DocumentTypeAsPayloadInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/DocumentTypeAsPayload").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::document_type_as_payload::DocumentTypeAsPayloadInput,
                 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)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_document_type_as_payload_input::ser_document_value_http_payload(&input.document_value)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut input = input;
         let payload = input.document_value.take();
         let mut request = protocol
             .serialize_request(&input, DocumentTypeAsPayload::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         if let ::std::option::Option::Some(payload) = payload {
             let mut json = String::new();
             ::aws_smithy_json::serialize::JsonValueWriter::new(&mut json).document(&payload);
             *request.body_mut() = ::aws_smithy_types::body::SdkBody::from(json.into_bytes());
             request.headers_mut().insert("Content-Type", "application/json");
             if let ::std::option::Option::Some(content_length) = request.body().content_length() {
                 request.headers_mut().insert("Content-Length", content_length.to_string());
-+
+            }
-+
+        }
-+
         return ::std::result::Result::Ok(request);
-221
+    }
-222
+}
 #[derive(Debug)]
 struct DocumentTypeAsPayloadEndpointParamsInterceptor;
-225
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DocumentTypeAsPayloadEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DocumentTypeAsPayloadEndpointParamsInterceptor"
-229
+    }
-230

↧ 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::<DocumentTypeAsPayloadInput>()
             .ok_or("failed to downcast to DocumentTypeAsPayloadInput")?;
-245
         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));

@@ -333,349 +443,479 @@

↥ Expand context

                     }"#;
                 let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"foo\": \"bar\"\n}"))
                 .unwrap(),
-360
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-364
         let op = crate::operation::document_type_as_payload::DocumentTypeAsPayload::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()

             .expect("the config must have a deserializer");
-370
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::document_type_as_payload::DocumentTypeAsPayloadOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.document_value,
             expected_output.document_value,
             "Unexpected value for `document_value`"
         );
-400
+    }
-401
     /// Serializes a document as a payload string.
     /// Test ID: DocumentTypeAsPayloadOutputString
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_type_as_payload_output_string_response() {
         let expected_output = crate::operation::document_type_as_payload::DocumentTypeAsPayloadOutput::builder()
             .set_document_value(::std::option::Option::Some({
                 let json_bytes = br#""hello""#;
                 let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("\"hello\""))
                 .unwrap(),
-420
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-424
         let op = crate::operation::document_type_as_payload::DocumentTypeAsPayload::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-430
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::document_type_as_payload::DocumentTypeAsPayloadOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.document_value,
             expected_output.document_value,
             "Unexpected value for `document_value`"
         );

↧ Expand context

-460
+    }
-461
+}
-462
 /// Error type for the `DocumentTypeAsPayloadError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum DocumentTypeAsPayloadError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-470
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-472
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-DocumentTypeAsPayloadError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-475
+}
 impl DocumentTypeAsPayloadError {
     /// Creates the `DocumentTypeAsPayloadError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/document_type_as_payload/_document_type_as_payload_input.rs

@@ -1,1 +109,130 @@

↥ 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 DocumentTypeAsPayloadInput {
     #[allow(missing_docs)] // documentation missing in model
     pub document_value: ::std::option::Option<::aws_smithy_types::Document>,
-8
+}
 impl DocumentTypeAsPayloadInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn document_value(&self) -> ::std::option::Option<&::aws_smithy_types::Document> {
         self.document_value.as_ref()
-13
+    }
-14
+}
 static DOCUMENTTYPEASPAYLOADINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#DocumentTypeAsPayloadInput",

     "aws.protocoltests.restjson.synthetic",
     "DocumentTypeAsPayloadInput",
 );
 static DOCUMENTTYPEASPAYLOADINPUT_MEMBER_DOCUMENT_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#DocumentTypeAsPayloadInput$documentValue",
         "aws.protocoltests.restjson.synthetic",
         "DocumentTypeAsPayloadInput",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "document_value",
     "documentValue",
 ,
-29
+)
 .with_http_payload();
 static DOCUMENTTYPEASPAYLOADINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DOCUMENTTYPEASPAYLOADINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DOCUMENTTYPEASPAYLOADINPUT_MEMBER_DOCUMENT_VALUE],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/DocumentTypeAsPayload", None));
 impl DocumentTypeAsPayloadInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DOCUMENTTYPEASPAYLOADINPUT_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DocumentTypeAsPayloadInput {
     #[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.document_value {
             ser.write_document(&DOCUMENTTYPEASPAYLOADINPUT_MEMBER_DOCUMENT_VALUE, val)?;
-49
+        }
         Ok(())
-51
+    }
-52
+}
 impl DocumentTypeAsPayloadInput {
     /// 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(&DOCUMENTTYPEASPAYLOADINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DOCUMENTTYPEASPAYLOADINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.document_value = Some(deser.read_document(member)?);
-71
+                }
                 _ => {}
-73
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-79
+    }
-80
+}
 impl DocumentTypeAsPayloadInput {
     /// 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 !body.is_empty() {
             builder.document_value = Some(deserializer.read_document(&DOCUMENTTYPEASPAYLOADINPUT_MEMBER_DOCUMENT_VALUE)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl DocumentTypeAsPayloadInput {
     /// Creates a new builder-style object to manufacture [`DocumentTypeAsPayloadInput`](crate::operation::document_type_as_payload::DocumentTypeAsPayloadInput).
     pub fn builder() -> crate::operation::document_type_as_payload::builders::DocumentTypeAsPayloadInputBuilder {
         crate::operation::document_type_as_payload::builders::DocumentTypeAsPayloadInputBuilder::default()
-105
+    }
-106
+}
-107
 /// A builder for [`DocumentTypeAsPayloadInput`](crate::operation::document_type_as_payload::DocumentTypeAsPayloadInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DocumentTypeAsPayloadInputBuilder {
     pub(crate) document_value: ::std::option::Option<::aws_smithy_types::Document>,
-113
+}
 impl DocumentTypeAsPayloadInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn document_value(mut self, input: ::aws_smithy_types::Document) -> Self {
         self.document_value = ::std::option::Option::Some(input);
         self
-119
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_document_value(mut self, input: ::std::option::Option<::aws_smithy_types::Document>) -> Self {
         self.document_value = input;
         self
-124
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_document_value(&self) -> &::std::option::Option<::aws_smithy_types::Document> {
         &self.document_value
-128
+    }
     /// Consumes the builder and constructs a [`DocumentTypeAsPayloadInput`](crate::operation::document_type_as_payload::DocumentTypeAsPayloadInput).
     pub fn build(

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/document_type_as_payload/_document_type_as_payload_output.rs

@@ -1,1 +107,125 @@

↥ 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 DocumentTypeAsPayloadOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub document_value: ::std::option::Option<::aws_smithy_types::Document>,
-8
+}
 impl DocumentTypeAsPayloadOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn document_value(&self) -> ::std::option::Option<&::aws_smithy_types::Document> {
         self.document_value.as_ref()
-13
+    }
-14
+}
 static DOCUMENTTYPEASPAYLOADOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#DocumentTypeAsPayloadOutput",

     "aws.protocoltests.restjson.synthetic",
     "DocumentTypeAsPayloadOutput",
 );
 static DOCUMENTTYPEASPAYLOADOUTPUT_MEMBER_DOCUMENT_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#DocumentTypeAsPayloadOutput$documentValue",
         "aws.protocoltests.restjson.synthetic",
         "DocumentTypeAsPayloadOutput",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "document_value",
     "documentValue",
 ,
-29
+)
 .with_http_payload();
 static DOCUMENTTYPEASPAYLOADOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DOCUMENTTYPEASPAYLOADOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DOCUMENTTYPEASPAYLOADOUTPUT_MEMBER_DOCUMENT_VALUE],
 );
 impl DocumentTypeAsPayloadOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DOCUMENTTYPEASPAYLOADOUTPUT_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DocumentTypeAsPayloadOutput {
     #[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.document_value {
             ser.write_document(&DOCUMENTTYPEASPAYLOADOUTPUT_MEMBER_DOCUMENT_VALUE, val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl DocumentTypeAsPayloadOutput {
     /// 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(&DOCUMENTTYPEASPAYLOADOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DOCUMENTTYPEASPAYLOADOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.document_value = Some(deser.read_document(member)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl DocumentTypeAsPayloadOutput {
     /// 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 !body.is_empty() {
             builder.document_value = Some(deserializer.read_document(&DOCUMENTTYPEASPAYLOADOUTPUT_MEMBER_DOCUMENT_VALUE)?);
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl DocumentTypeAsPayloadOutput {
     /// Creates a new builder-style object to manufacture [`DocumentTypeAsPayloadOutput`](crate::operation::document_type_as_payload::DocumentTypeAsPayloadOutput).
     pub fn builder() -> crate::operation::document_type_as_payload::builders::DocumentTypeAsPayloadOutputBuilder {
         crate::operation::document_type_as_payload::builders::DocumentTypeAsPayloadOutputBuilder::default()
-100
+    }
-101
+}
-102
 /// A builder for [`DocumentTypeAsPayloadOutput`](crate::operation::document_type_as_payload::DocumentTypeAsPayloadOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DocumentTypeAsPayloadOutputBuilder {
     pub(crate) document_value: ::std::option::Option<::aws_smithy_types::Document>,
-108
+}
 impl DocumentTypeAsPayloadOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn document_value(mut self, input: ::aws_smithy_types::Document) -> Self {
         self.document_value = ::std::option::Option::Some(input);
         self
-114
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_document_value(mut self, input: ::std::option::Option<::aws_smithy_types::Document>) -> Self {
         self.document_value = input;
         self
-119
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_document_value(&self) -> &::std::option::Option<::aws_smithy_types::Document> {
         &self.document_value
-123
+    }
     /// Consumes the builder and constructs a [`DocumentTypeAsPayloadOutput`](crate::operation::document_type_as_payload::DocumentTypeAsPayloadOutput).
     pub fn build(self) -> crate::operation::document_type_as_payload::DocumentTypeAsPayloadOutput {

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/duplex_stream.rs

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

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

@@ -119,123 +247,271 @@

↥ Expand context

             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::duplex_stream::DuplexStreamError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::duplex_stream::DuplexStreamError,
             >::new());
-129
         ::std::borrow::Cow::Owned(rcb)
-131
+    }
-132
+}
-133
 #[derive(Debug)]
 struct DuplexStreamResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DuplexStreamResponseDeserializer {
     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;

-143
         // 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;
-147
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_duplex_stream::de_duplex_stream_http_response(response),
         ))
-151
+    }
-152
     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_duplex_stream::de_duplex_stream_http_error(
             response.status().as_u16(),
             response.headers(),
             body,
         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::duplex_stream::DuplexStreamError::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 {
             "ErrorEvent" => crate::operation::duplex_stream::DuplexStreamError::ErrorEvent({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ErrorEvent::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ErrorEvent::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::duplex_stream::DuplexStreamError::generic(generic),
         };
         ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
             ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         ))
-205
+    }
-206
+}
 #[derive(Debug)]
 struct DuplexStreamRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DuplexStreamRequestSerializer {
     #[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::duplex_stream::DuplexStreamInput>()
             .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::duplex_stream::DuplexStreamInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/DuplexStream").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::duplex_stream::DuplexStreamInput,
                 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)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from({
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, DuplexStream::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         *request.body_mut() = ::aws_smithy_types::body::SdkBody::from({
             let error_marshaller = crate::event_stream_serde::EventStreamErrorMarshaller::new();
             let marshaller = crate::event_stream_serde::EventStreamMarshaller::new();
             let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
             _cfg.interceptor_state().store_put(signer_sender);
             ::aws_smithy_types::body::SdkBody::from_body_1_x(::http_body_util::StreamBody::new(input.stream.into_body_stream(
                 marshaller,
                 error_marshaller,
                 signer,
             )))
         });
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         // The protocol may have set Content-Length based on the initial empty body.
         // Remove it since the event stream body has unknown length.
         request.headers_mut().remove("Content-Length");
         request.headers_mut().insert("Content-Type", "application/vnd.amazon.eventstream");
-+
         return ::std::result::Result::Ok(request);
-242
+    }
-243
+}
 #[derive(Debug)]
 struct DuplexStreamEndpointParamsInterceptor;
-246
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DuplexStreamEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DuplexStreamEndpointParamsInterceptor"
-250
+    }
-251

↧ 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::<DuplexStreamInput>()
             .ok_or("failed to downcast to DuplexStreamInput")?;
-266
         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/rest_json/rust-client-codegen/src/operation/duplex_stream/_duplex_stream_input.rs

@@ -5,5 +113,121 @@

↥ Expand context

 pub struct DuplexStreamInput {
     #[allow(missing_docs)] // documentation missing in model
     pub stream: ::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>,
-8
+}
 impl DuplexStreamInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn stream(&self) -> &::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError> {
         &self.stream
-13
+    }
-14
+}
 static DUPLEXSTREAMINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#DuplexStreamInput",
     "aws.protocoltests.restjson.synthetic",
     "DuplexStreamInput",
 );
 static DUPLEXSTREAMINPUT_MEMBER_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#DuplexStreamInput$stream",
         "aws.protocoltests.restjson.synthetic",
         "DuplexStreamInput",

     ),
     ::aws_smithy_schema::ShapeType::Union,
     "stream",
 ,
-29
+)
 .with_http_payload();
 static DUPLEXSTREAMINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DUPLEXSTREAMINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DUPLEXSTREAMINPUT_MEMBER_STREAM],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/DuplexStream", None));
 impl DuplexStreamInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DUPLEXSTREAMINPUT_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DuplexStreamInput {
     #[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> {
--
+        {
             let val = &self.stream;
             ser.write_null(&DUPLEXSTREAMINPUT_MEMBER_STREAM)?;
--
+        }
         Ok(())
-48
+    }
-49
+}
 impl DuplexStreamInput {
     /// 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(&DUPLEXSTREAMINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DUPLEXSTREAMINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-71
+                }
                 _ => {}
-73
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-79
+    }
-80
+}
 impl DuplexStreamInput {
     /// 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 DuplexStreamInput {
     /// Creates a new builder-style object to manufacture [`DuplexStreamInput`](crate::operation::duplex_stream::DuplexStreamInput).
     pub fn builder() -> crate::operation::duplex_stream::builders::DuplexStreamInputBuilder {
         crate::operation::duplex_stream::builders::DuplexStreamInputBuilder::default()
-96
+    }
-97
+}
-98
 /// A builder for [`DuplexStreamInput`](crate::operation::duplex_stream::DuplexStreamInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DuplexStreamInputBuilder {
     pub(crate) stream:
         ::std::option::Option<::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>>,
-105
+}
 impl DuplexStreamInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn stream(
         mut self,
         input: ::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>,
     ) -> Self {
         self.stream = ::std::option::Option::Some(input);
         self
-114
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_stream(
         mut self,
         input: ::std::option::Option<
             ::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>,
         >,
     ) -> Self {

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/duplex_stream/_duplex_stream_output.rs

@@ -16,16 +113,120 @@

↥ Expand context

     "aws.protocoltests.restjson.synthetic#DuplexStreamOutput",
     "aws.protocoltests.restjson.synthetic",
     "DuplexStreamOutput",
 );
 static DUPLEXSTREAMOUTPUT_MEMBER_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#DuplexStreamOutput$stream",
         "aws.protocoltests.restjson.synthetic",
         "DuplexStreamOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "stream",
 ,
-29
+)
 .with_http_payload();
 static DUPLEXSTREAMOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DUPLEXSTREAMOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DUPLEXSTREAMOUTPUT_MEMBER_STREAM],
 );

 impl DuplexStreamOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DUPLEXSTREAMOUTPUT_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DuplexStreamOutput {
     #[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> {
--
+        {
             let val = &self.stream;
             ser.write_null(&DUPLEXSTREAMOUTPUT_MEMBER_STREAM)?;
--
+        }
         Ok(())
-47
+    }
-48
+}
 impl DuplexStreamOutput {
     /// 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(&DUPLEXSTREAMOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DUPLEXSTREAMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-78
+    }
-79
+}
 impl DuplexStreamOutput {
     /// 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 DuplexStreamOutput {
     /// Creates a new builder-style object to manufacture [`DuplexStreamOutput`](crate::operation::duplex_stream::DuplexStreamOutput).
     pub fn builder() -> crate::operation::duplex_stream::builders::DuplexStreamOutputBuilder {
         crate::operation::duplex_stream::builders::DuplexStreamOutputBuilder::default()
-95
+    }
-96
+}
-97
 /// A builder for [`DuplexStreamOutput`](crate::operation::duplex_stream::DuplexStreamOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DuplexStreamOutputBuilder {
     pub(crate) stream: ::std::option::Option<crate::event_receiver::EventReceiver<crate::types::EventStream, crate::types::error::EventStreamError>>,
-103
+}
 impl DuplexStreamOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn stream(mut self, input: crate::event_receiver::EventReceiver<crate::types::EventStream, crate::types::error::EventStreamError>) -> Self {
         self.stream = ::std::option::Option::Some(input);
         self
-109
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_stream(
         mut self,
         input: ::std::option::Option<crate::event_receiver::EventReceiver<crate::types::EventStream, crate::types::error::EventStreamError>>,
     ) -> Self {
         self.stream = input;
         self
-117
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_stream(
         &self,

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/duplex_stream_with_distinct_streams.rs

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

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

@@ -109,115 +244,294 @@

↥ Expand context

-115
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "DuplexStreamWithDistinctStreams",
             "Rest Json Protocol",
         ));
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DuplexStreamWithDistinctStreams")
             .with_interceptor(DuplexStreamWithDistinctStreamsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsError,
             >::new());
-137
         ::std::borrow::Cow::Owned(rcb)
-139
+    }
-140
+}
-141
 #[derive(Debug)]
 struct DuplexStreamWithDistinctStreamsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DuplexStreamWithDistinctStreamsResponseDeserializer {
     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))
             })?;
-161
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_duplex_stream_with_distinct_streams::de_duplex_stream_with_distinct_streams_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_duplex_stream_with_distinct_streams::de_duplex_stream_with_distinct_streams_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::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsError::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 {
                 "ErrorEvent" => crate::operation::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsError::ErrorEvent({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ErrorEvent::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ErrorEvent::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-187
+                            )
                         }) {
                         ::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::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsError::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, DuplexStreamWithDistinctStreams::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::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsOutput::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))
-+
+        }
-228
+    }
-229
+}
 #[derive(Debug)]
 struct DuplexStreamWithDistinctStreamsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DuplexStreamWithDistinctStreamsRequestSerializer {
     #[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::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsInput>()
             .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::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/DuplexStreamWithDistinctStreams").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsInput,
                 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)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from({
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, DuplexStreamWithDistinctStreams::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         *request.body_mut() = ::aws_smithy_types::body::SdkBody::from({
             let error_marshaller = crate::event_stream_serde::EventStreamErrorMarshaller::new();
             let marshaller = crate::event_stream_serde::EventStreamMarshaller::new();
             let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
             _cfg.interceptor_state().store_put(signer_sender);
             ::aws_smithy_types::body::SdkBody::from_body_1_x(::http_body_util::StreamBody::new(input.stream.into_body_stream(
                 marshaller,
                 error_marshaller,
                 signer,
             )))
         });
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         // The protocol may have set Content-Length based on the initial empty body.
         // Remove it since the event stream body has unknown length.
         request.headers_mut().remove("Content-Length");
         request.headers_mut().insert("Content-Type", "application/vnd.amazon.eventstream");
-+
         return ::std::result::Result::Ok(request);
-265
+    }
-266
+}
 #[derive(Debug)]
 struct DuplexStreamWithDistinctStreamsEndpointParamsInterceptor;
-269
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DuplexStreamWithDistinctStreamsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DuplexStreamWithDistinctStreamsEndpointParamsInterceptor"
-273
+    }
-274

↧ 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::<DuplexStreamWithDistinctStreamsInput>()
             .ok_or("failed to downcast to DuplexStreamWithDistinctStreamsInput")?;
-289
         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/rest_json/rust-client-codegen/src/operation/duplex_stream_with_distinct_streams/_duplex_stream_with_distinct_streams_input.rs

@@ -5,5 +113,125 @@

↥ Expand context

 pub struct DuplexStreamWithDistinctStreamsInput {
     #[allow(missing_docs)] // documentation missing in model
     pub stream: ::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>,
-8
+}
 impl DuplexStreamWithDistinctStreamsInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn stream(&self) -> &::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError> {
         &self.stream
-13
+    }
-14
+}
 static DUPLEXSTREAMWITHDISTINCTSTREAMSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#DuplexStreamWithDistinctStreamsInput",
     "aws.protocoltests.restjson.synthetic",
     "DuplexStreamWithDistinctStreamsInput",
 );
 static DUPLEXSTREAMWITHDISTINCTSTREAMSINPUT_MEMBER_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#DuplexStreamWithDistinctStreamsInput$stream",
         "aws.protocoltests.restjson.synthetic",
         "DuplexStreamWithDistinctStreamsInput",

     ),
     ::aws_smithy_schema::ShapeType::Union,
     "stream",
 ,
-29
+)
 .with_http_payload();
 static DUPLEXSTREAMWITHDISTINCTSTREAMSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DUPLEXSTREAMWITHDISTINCTSTREAMSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DUPLEXSTREAMWITHDISTINCTSTREAMSINPUT_MEMBER_STREAM],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "POST",
     "/DuplexStreamWithDistinctStreams",
     None,
 ));
 impl DuplexStreamWithDistinctStreamsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DUPLEXSTREAMWITHDISTINCTSTREAMSINPUT_SCHEMA;
-44
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DuplexStreamWithDistinctStreamsInput {
     #[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> {
--
+        {
             let val = &self.stream;
             ser.write_null(&DUPLEXSTREAMWITHDISTINCTSTREAMSINPUT_MEMBER_STREAM)?;
--
+        }
         Ok(())
-52
+    }
-53
+}
 impl DuplexStreamWithDistinctStreamsInput {
     /// 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(&DUPLEXSTREAMWITHDISTINCTSTREAMSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DUPLEXSTREAMWITHDISTINCTSTREAMSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-75
+                }
                 _ => {}
-77
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-83
+    }
-84
+}
 impl DuplexStreamWithDistinctStreamsInput {
     /// 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 DuplexStreamWithDistinctStreamsInput {
     /// Creates a new builder-style object to manufacture [`DuplexStreamWithDistinctStreamsInput`](crate::operation::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsInput).
     pub fn builder() -> crate::operation::duplex_stream_with_distinct_streams::builders::DuplexStreamWithDistinctStreamsInputBuilder {
         crate::operation::duplex_stream_with_distinct_streams::builders::DuplexStreamWithDistinctStreamsInputBuilder::default()
-100
+    }
-101
+}
-102
 /// A builder for [`DuplexStreamWithDistinctStreamsInput`](crate::operation::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DuplexStreamWithDistinctStreamsInputBuilder {
     pub(crate) stream:
         ::std::option::Option<::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>>,
-109
+}
 impl DuplexStreamWithDistinctStreamsInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn stream(
         mut self,
         input: ::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>,
     ) -> Self {
         self.stream = ::std::option::Option::Some(input);
         self
-118
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_stream(
         mut self,
         input: ::std::option::Option<
             ::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>,
         >,
     ) -> Self {

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/duplex_stream_with_distinct_streams/_duplex_stream_with_distinct_streams_output.rs

@@ -17,17 +110,125 @@

↥ Expand context

     "aws.protocoltests.restjson.synthetic",
     "DuplexStreamWithDistinctStreamsOutput",
 );
 static DUPLEXSTREAMWITHDISTINCTSTREAMSOUTPUT_MEMBER_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#DuplexStreamWithDistinctStreamsOutput$stream",
         "aws.protocoltests.restjson.synthetic",
         "DuplexStreamWithDistinctStreamsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "stream",
 ,
-29
+)
 .with_http_payload();
 static DUPLEXSTREAMWITHDISTINCTSTREAMSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DUPLEXSTREAMWITHDISTINCTSTREAMSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DUPLEXSTREAMWITHDISTINCTSTREAMSOUTPUT_MEMBER_STREAM],
 );
 impl DuplexStreamWithDistinctStreamsOutput {

     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DUPLEXSTREAMWITHDISTINCTSTREAMSOUTPUT_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DuplexStreamWithDistinctStreamsOutput {
     #[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.stream {
             ser.write_null(&DUPLEXSTREAMWITHDISTINCTSTREAMSOUTPUT_MEMBER_STREAM)?;
             ser.write_struct(&DUPLEXSTREAMWITHDISTINCTSTREAMSOUTPUT_MEMBER_STREAM, val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl DuplexStreamWithDistinctStreamsOutput {
     /// 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(&DUPLEXSTREAMWITHDISTINCTSTREAMSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DUPLEXSTREAMWITHDISTINCTSTREAMSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                     });
                     builder.stream = Some(crate::types::SingletonEventStream::deserialize(deser)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl DuplexStreamWithDistinctStreamsOutput {
     /// 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 !body.is_empty() {
             builder.stream = Some(crate::types::SingletonEventStream::deserialize(deserializer)?);
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl DuplexStreamWithDistinctStreamsOutput {
     /// Creates a new builder-style object to manufacture [`DuplexStreamWithDistinctStreamsOutput`](crate::operation::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsOutput).
     pub fn builder() -> crate::operation::duplex_stream_with_distinct_streams::builders::DuplexStreamWithDistinctStreamsOutputBuilder {
         crate::operation::duplex_stream_with_distinct_streams::builders::DuplexStreamWithDistinctStreamsOutputBuilder::default()
-100
+    }
-101
+}
-102
 /// A builder for [`DuplexStreamWithDistinctStreamsOutput`](crate::operation::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DuplexStreamWithDistinctStreamsOutputBuilder {
     pub(crate) stream: ::std::option::Option<crate::types::SingletonEventStream>,
-108
+}
 impl DuplexStreamWithDistinctStreamsOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn stream(mut self, input: crate::types::SingletonEventStream) -> Self {
         self.stream = ::std::option::Option::Some(input);
         self
-114
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_stream(mut self, input: ::std::option::Option<crate::types::SingletonEventStream>) -> Self {
         self.stream = input;
         self
-119
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_stream(&self) -> &::std::option::Option<crate::types::SingletonEventStream> {
         &self.stream
-123
+    }
     /// Consumes the builder and constructs a [`DuplexStreamWithDistinctStreamsOutput`](crate::operation::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsOutput).
     pub fn build(self) -> crate::operation::duplex_stream_with_distinct_streams::DuplexStreamWithDistinctStreamsOutput {

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/duplex_stream_with_initial_messages.rs

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

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

@@ -125,131 +258,307 @@

↥ Expand context

             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::duplex_stream_with_initial_messages::DuplexStreamWithInitialMessagesError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::duplex_stream_with_initial_messages::DuplexStreamWithInitialMessagesError,
             >::new());
-137
         ::std::borrow::Cow::Owned(rcb)
-139
+    }
-140
+}
-141
 #[derive(Debug)]
 struct DuplexStreamWithInitialMessagesResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DuplexStreamWithInitialMessagesResponseDeserializer {
     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;

-151
         // 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;
-155
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_duplex_stream_with_initial_messages::de_duplex_stream_with_initial_messages_http_response(response),
         ))
-159
+    }
-160
     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_duplex_stream_with_initial_messages::de_duplex_stream_with_initial_messages_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::duplex_stream_with_initial_messages::DuplexStreamWithInitialMessagesError::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 {
             "ServiceUnavailableError" => {
                 crate::operation::duplex_stream_with_initial_messages::DuplexStreamWithInitialMessagesError::ServiceUnavailableError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceUnavailableError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceUnavailableError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
             ),
-201
+                            )
                         }) {
                         ::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
                 })
-+
+            }
             "ErrorEvent" => crate::operation::duplex_stream_with_initial_messages::DuplexStreamWithInitialMessagesError::ErrorEvent({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ErrorEvent::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ErrorEvent::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::duplex_stream_with_initial_messages::DuplexStreamWithInitialMessagesError::generic(generic),
         };
         ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
             ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         ))
-241
+    }
-242
+}
 #[derive(Debug)]
 struct DuplexStreamWithInitialMessagesRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DuplexStreamWithInitialMessagesRequestSerializer {
     #[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::duplex_stream_with_initial_messages::DuplexStreamWithInitialMessagesInput>()
             .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::duplex_stream_with_initial_messages::DuplexStreamWithInitialMessagesInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/DuplexStreamWithInitialMessages").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::duplex_stream_with_initial_messages::DuplexStreamWithInitialMessagesInput,
                 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_duplex_stream_with_initial_messages::ser_duplex_stream_with_initial_messages_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 =
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from({
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, DuplexStreamWithInitialMessages::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         *request.body_mut() = ::aws_smithy_types::body::SdkBody::from({
             let error_marshaller = crate::event_stream_serde::EventStreamErrorMarshaller::new();
             let marshaller = crate::event_stream_serde::EventStreamMarshaller::new();
             let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
             _cfg.interceptor_state().store_put(signer_sender);
             ::aws_smithy_types::body::SdkBody::from_body_1_x(::http_body_util::StreamBody::new(input.stream.into_body_stream(
                 marshaller,
                 error_marshaller,
                 signer,
             )))
         });
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         // The protocol may have set Content-Length based on the initial empty body.
         // Remove it since the event stream body has unknown length.
         request.headers_mut().remove("Content-Length");
         request.headers_mut().insert("Content-Type", "application/vnd.amazon.eventstream");
-+
         return ::std::result::Result::Ok(request);
-278
+    }
-279
+}
 #[derive(Debug)]
 struct DuplexStreamWithInitialMessagesEndpointParamsInterceptor;
-282
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DuplexStreamWithInitialMessagesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DuplexStreamWithInitialMessagesEndpointParamsInterceptor"
-286
+    }
-287

↧ 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::<DuplexStreamWithInitialMessagesInput>()
             .ok_or("failed to downcast to DuplexStreamWithInitialMessagesInput")?;
-302
         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/rest_json/rust-client-codegen/src/operation/duplex_stream_with_initial_messages/_duplex_stream_with_initial_messages_input.rs

@@ -3,3 +128,170 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub struct DuplexStreamWithInitialMessagesInput {
     #[allow(missing_docs)] // documentation missing in model
     pub initial_request_member: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub stream: ::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>,
-10
+}
 impl DuplexStreamWithInitialMessagesInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn initial_request_member(&self) -> ::std::option::Option<&str> {
         self.initial_request_member.as_deref()
-15
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn stream(&self) -> &::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError> {
         &self.stream
-19
+    }
-20
+}
 static DUPLEXSTREAMWITHINITIALMESSAGESINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#DuplexStreamWithInitialMessagesInput",

     "aws.protocoltests.restjson.synthetic",
     "DuplexStreamWithInitialMessagesInput",
 );
 static DUPLEXSTREAMWITHINITIALMESSAGESINPUT_MEMBER_INITIAL_REQUEST_MEMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#DuplexStreamWithInitialMessagesInput$initialRequestMember",
         "aws.protocoltests.restjson.synthetic",
         "DuplexStreamWithInitialMessagesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "initial_request_member",
     "initialRequestMember",
 ,
-35
+)
 .with_http_header("initial-request-member");
 static DUPLEXSTREAMWITHINITIALMESSAGESINPUT_MEMBER_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#DuplexStreamWithInitialMessagesInput$stream",
         "aws.protocoltests.restjson.synthetic",
         "DuplexStreamWithInitialMessagesInput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "stream",
 ,
-46
+)
 .with_http_payload();
 static DUPLEXSTREAMWITHINITIALMESSAGESINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DUPLEXSTREAMWITHINITIALMESSAGESINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DUPLEXSTREAMWITHINITIALMESSAGESINPUT_MEMBER_INITIAL_REQUEST_MEMBER,
         &DUPLEXSTREAMWITHINITIALMESSAGESINPUT_MEMBER_STREAM,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "POST",
     "/DuplexStreamWithInitialMessages",
     None,
 ));
 impl DuplexStreamWithInitialMessagesInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DUPLEXSTREAMWITHINITIALMESSAGESINPUT_SCHEMA;
-64
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DuplexStreamWithInitialMessagesInput {
     #[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.initial_request_member {
             ser.write_string(&DUPLEXSTREAMWITHINITIALMESSAGESINPUT_MEMBER_INITIAL_REQUEST_MEMBER, val)?;
-73
+        }
--
+        {
             let val = &self.stream;
             ser.write_null(&DUPLEXSTREAMWITHINITIALMESSAGESINPUT_MEMBER_STREAM)?;
--
+        }
         Ok(())
-75
+    }
-76
+}
 impl DuplexStreamWithInitialMessagesInput {
     /// 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(&DUPLEXSTREAMWITHINITIALMESSAGESINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DUPLEXSTREAMWITHINITIALMESSAGESINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.initial_request_member = Some(deser.read_string(member)?);
-95
+                }
                 Some(1) => {
                     builder.stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.initial_request_member = builder.initial_request_member.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl DuplexStreamWithInitialMessagesInput {
     /// 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("initial-request-member") {
             builder.initial_request_member = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&DUPLEXSTREAMWITHINITIALMESSAGESINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.stream = Some({
                         let _ = member;
                         todo!("deserialize streaming union")
                     });
-142
+                }
                 _ => {}
-144
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-150
+    }

↧ Expand context

-151
+}
 impl DuplexStreamWithInitialMessagesInput {
     /// Creates a new builder-style object to manufacture [`DuplexStreamWithInitialMessagesInput`](crate::operation::duplex_stream_with_initial_messages::DuplexStreamWithInitialMessagesInput).
     pub fn builder() -> crate::operation::duplex_stream_with_initial_messages::builders::DuplexStreamWithInitialMessagesInputBuilder {
         crate::operation::duplex_stream_with_initial_messages::builders::DuplexStreamWithInitialMessagesInputBuilder::default()
-156
+    }
-157
+}
-158
 /// A builder for [`DuplexStreamWithInitialMessagesInput`](crate::operation::duplex_stream_with_initial_messages::DuplexStreamWithInitialMessagesInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct DuplexStreamWithInitialMessagesInputBuilder {
     pub(crate) initial_request_member: ::std::option::Option<::std::string::String>,
     pub(crate) stream:
         ::std::option::Option<::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>>,
-166
+}
 impl DuplexStreamWithInitialMessagesInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     /// This field is required.
     pub fn initial_request_member(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/duplex_stream_with_initial_messages/_duplex_stream_with_initial_messages_output.rs

@@ -4,4 +130,167 @@

↥ Expand context

 #[derive(::std::fmt::Debug)]
 pub struct DuplexStreamWithInitialMessagesOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub initial_response_member: ::std::string::String,
     #[allow(missing_docs)] // documentation missing in model
     pub stream: crate::event_receiver::EventReceiver<crate::types::EventStream, crate::types::error::EventStreamError>,
-10
+}
 impl DuplexStreamWithInitialMessagesOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn initial_response_member(&self) -> &str {
         use std::ops::Deref;
         self.initial_response_member.deref()
-16
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn stream(&self) -> &crate::event_receiver::EventReceiver<crate::types::EventStream, crate::types::error::EventStreamError> {
         &self.stream
-20
+    }
-21
+}
 static DUPLEXSTREAMWITHINITIALMESSAGESOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#DuplexStreamWithInitialMessagesOutput",

     "aws.protocoltests.restjson.synthetic",
     "DuplexStreamWithInitialMessagesOutput",
 );
 static DUPLEXSTREAMWITHINITIALMESSAGESOUTPUT_MEMBER_INITIAL_RESPONSE_MEMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#DuplexStreamWithInitialMessagesOutput$initialResponseMember",
         "aws.protocoltests.restjson.synthetic",
         "DuplexStreamWithInitialMessagesOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "initial_response_member",
     "initialResponseMember",
 ,
-36
+)
 .with_http_header("initial-response-member");
 static DUPLEXSTREAMWITHINITIALMESSAGESOUTPUT_MEMBER_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#DuplexStreamWithInitialMessagesOutput$stream",
         "aws.protocoltests.restjson.synthetic",
         "DuplexStreamWithInitialMessagesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "stream",
 ,
-47
+)
 .with_http_payload();
 static DUPLEXSTREAMWITHINITIALMESSAGESOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DUPLEXSTREAMWITHINITIALMESSAGESOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DUPLEXSTREAMWITHINITIALMESSAGESOUTPUT_MEMBER_INITIAL_RESPONSE_MEMBER,
         &DUPLEXSTREAMWITHINITIALMESSAGESOUTPUT_MEMBER_STREAM,
     ],
 );
 impl DuplexStreamWithInitialMessagesOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DUPLEXSTREAMWITHINITIALMESSAGESOUTPUT_SCHEMA;
-60
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DuplexStreamWithInitialMessagesOutput {
     #[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> {
-67
+        {
             let val = &self.initial_response_member;
             ser.write_string(&DUPLEXSTREAMWITHINITIALMESSAGESOUTPUT_MEMBER_INITIAL_RESPONSE_MEMBER, val)?;
-70
+        }
--
+        {
             let val = &self.stream;
             ser.write_null(&DUPLEXSTREAMWITHINITIALMESSAGESOUTPUT_MEMBER_STREAM)?;
--
+        }
         Ok(())
-72
+    }
-73
+}
 impl DuplexStreamWithInitialMessagesOutput {
     /// 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(&DUPLEXSTREAMWITHINITIALMESSAGESOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DUPLEXSTREAMWITHINITIALMESSAGESOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.initial_response_member = Some(deser.read_string(member)?);
-92
+                }
                 Some(1) => {
                     builder.stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.initial_response_member = builder.initial_response_member.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl DuplexStreamWithInitialMessagesOutput {
     /// 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("initial-response-member") {
             builder.initial_response_member = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&DUPLEXSTREAMWITHINITIALMESSAGESOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.stream = Some({
                         let _ = member;
                         todo!("deserialize streaming union")
                     });
-139
+                }
                 _ => {}
-141
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-147
+    }

↧ Expand context

-148
+}
 impl DuplexStreamWithInitialMessagesOutput {
     /// Creates a new builder-style object to manufacture [`DuplexStreamWithInitialMessagesOutput`](crate::operation::duplex_stream_with_initial_messages::DuplexStreamWithInitialMessagesOutput).
     pub fn builder() -> crate::operation::duplex_stream_with_initial_messages::builders::DuplexStreamWithInitialMessagesOutputBuilder {
         crate::operation::duplex_stream_with_initial_messages::builders::DuplexStreamWithInitialMessagesOutputBuilder::default()
-153
+    }
-154
+}
-155
 /// A builder for [`DuplexStreamWithInitialMessagesOutput`](crate::operation::duplex_stream_with_initial_messages::DuplexStreamWithInitialMessagesOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct DuplexStreamWithInitialMessagesOutputBuilder {
     pub(crate) initial_response_member: ::std::option::Option<::std::string::String>,
     pub(crate) stream: ::std::option::Option<crate::event_receiver::EventReceiver<crate::types::EventStream, crate::types::error::EventStreamError>>,
-162
+}
 impl DuplexStreamWithInitialMessagesOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     /// This field is required.
     pub fn initial_response_member(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.initial_response_member = ::std::option::Option::Some(input.into());

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/empty_input_and_empty_output.rs

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

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

@@ -110,116 +228,241 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "EmptyInputAndEmptyOutput",
             "Rest Json Protocol",
         ));
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("EmptyInputAndEmptyOutput")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(EmptyInputAndEmptyOutputEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputError,
             >::new());
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct EmptyInputAndEmptyOutputResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for EmptyInputAndEmptyOutputResponseDeserializer {
     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))
             })?;
-162
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_empty_input_and_empty_output::de_empty_input_and_empty_output_http_error(status, headers, body)
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_empty_input_and_empty_output::de_empty_input_and_empty_output_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, EmptyInputAndEmptyOutput::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::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput::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))
-+
+        }
-190
+    }
-191
+}
 #[derive(Debug)]
 struct EmptyInputAndEmptyOutputRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for EmptyInputAndEmptyOutputRequestSerializer {
     #[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::empty_input_and_empty_output::EmptyInputAndEmptyOutputInput>()
             .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::empty_input_and_empty_output::EmptyInputAndEmptyOutputInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/EmptyInputAndEmptyOutput").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputInput,
                 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)?;
                 ::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("");
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, EmptyInputAndEmptyOutput::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-210
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-212
+    }
-213
+}
 #[derive(Debug)]
 struct EmptyInputAndEmptyOutputEndpointParamsInterceptor;
-216
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EmptyInputAndEmptyOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EmptyInputAndEmptyOutputEndpointParamsInterceptor"
-220
+    }
-221

↧ 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::<EmptyInputAndEmptyOutputInput>()
             .ok_or("failed to downcast to EmptyInputAndEmptyOutputInput")?;
-236
         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));

@@ -270,283 +369,402 @@

↥ Expand context

     /// Test ID: RestJsonEmptyInputAndEmptyOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_empty_input_and_empty_output_response() {
         let expected_output = crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{}"))
                 .unwrap(),
-294
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-298
         let op = crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutput::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()

             .expect("the config must have a deserializer");
-304
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput>()
             .unwrap();
-329
+    }
-330
     /// This test ensures that clients can gracefully handle
     /// situations where a service omits a JSON payload entirely.
     /// Test ID: RestJsonEmptyInputAndEmptyOutputJsonObjectOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_empty_input_and_empty_output_json_object_output_response() {
         let expected_output = crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-343
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-347
         let op = crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutput::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-353
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("unknown"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput>()
             .unwrap();
-378
+    }
-379
+}
-380
 /// Error type for the `EmptyInputAndEmptyOutputError` operation.
 #[non_exhaustive]

↧ Expand context

 #[derive(::std::fmt::Debug)]
 pub enum EmptyInputAndEmptyOutputError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-388
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-390
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-EmptyInputAndEmptyOutputError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-393
+}
 impl EmptyInputAndEmptyOutputError {
     /// Creates the `EmptyInputAndEmptyOutputError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/empty_input_and_empty_output/_empty_input_and_empty_output_input.rs

@@ -1,1 +72,86 @@

↥ Expand context

 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct EmptyInputAndEmptyOutputInput {}
 static EMPTYINPUTANDEMPTYOUTPUTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#EmptyInputAndEmptyOutputInput",
     "aws.protocoltests.restjson.synthetic",
     "EmptyInputAndEmptyOutputInput",
 );
 static EMPTYINPUTANDEMPTYOUTPUTINPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(EMPTYINPUTANDEMPTYOUTPUTINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
     ::aws_smithy_schema::Schema::new_struct(EMPTYINPUTANDEMPTYOUTPUTINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[])
         .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/EmptyInputAndEmptyOutput", None));
 impl EmptyInputAndEmptyOutputInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EMPTYINPUTANDEMPTYOUTPUTINPUT_SCHEMA;
-17
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EmptyInputAndEmptyOutputInput {
     #[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> {
         Ok(())
-25
+    }
-26
+}
 impl EmptyInputAndEmptyOutputInput {
     /// 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(&EMPTYINPUTANDEMPTYOUTPUTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EMPTYINPUTANDEMPTYOUTPUTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-44
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-50
+    }
-51
+}
 impl EmptyInputAndEmptyOutputInput {
     /// 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::builder()
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl EmptyInputAndEmptyOutputInput {
     /// Creates a new builder-style object to manufacture [`EmptyInputAndEmptyOutputInput`](crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputInput).
     pub fn builder() -> crate::operation::empty_input_and_empty_output::builders::EmptyInputAndEmptyOutputInputBuilder {
         crate::operation::empty_input_and_empty_output::builders::EmptyInputAndEmptyOutputInputBuilder::default()
-69
+    }
-70
+}
-71
 /// A builder for [`EmptyInputAndEmptyOutputInput`](crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EmptyInputAndEmptyOutputInputBuilder {}
 impl EmptyInputAndEmptyOutputInputBuilder {
     /// Consumes the builder and constructs a [`EmptyInputAndEmptyOutputInput`](crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputInput).
     pub fn build(
         self,
     ) -> ::std::result::Result<
         crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputInput,
         ::aws_smithy_types::error::operation::BuildError,
     > {
         ::std::result::Result::Ok(crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputInput {})
-85
+    }
-86
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/empty_input_and_empty_output/_empty_input_and_empty_output_output.rs

@@ -1,1 +65,76 @@

↥ 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 EmptyInputAndEmptyOutputOutput {}
 static EMPTYINPUTANDEMPTYOUTPUTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#EmptyInputAndEmptyOutputOutput",
     "aws.protocoltests.restjson.synthetic",
     "EmptyInputAndEmptyOutputOutput",
 );
 static EMPTYINPUTANDEMPTYOUTPUTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(EMPTYINPUTANDEMPTYOUTPUTOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl EmptyInputAndEmptyOutputOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EMPTYINPUTANDEMPTYOUTPUTOUTPUT_SCHEMA;
-16
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EmptyInputAndEmptyOutputOutput {

     #[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> {
         Ok(())
-24
+    }
-25
+}
 impl EmptyInputAndEmptyOutputOutput {
     /// 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(&EMPTYINPUTANDEMPTYOUTPUTOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EMPTYINPUTANDEMPTYOUTPUTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-43
+            }
             Ok(())
         })?;
         Ok(builder.build())
-47
+    }
-48
+}
 impl EmptyInputAndEmptyOutputOutput {
     /// 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> {
         Ok(Self::builder().build())
-+
+    }
-+
+}
 impl EmptyInputAndEmptyOutputOutput {
     /// Creates a new builder-style object to manufacture [`EmptyInputAndEmptyOutputOutput`](crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput).
     pub fn builder() -> crate::operation::empty_input_and_empty_output::builders::EmptyInputAndEmptyOutputOutputBuilder {
         crate::operation::empty_input_and_empty_output::builders::EmptyInputAndEmptyOutputOutputBuilder::default()
-64
+    }
-65
+}
-66
 /// A builder for [`EmptyInputAndEmptyOutputOutput`](crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EmptyInputAndEmptyOutputOutputBuilder {}
 impl EmptyInputAndEmptyOutputOutputBuilder {
     /// Consumes the builder and constructs a [`EmptyInputAndEmptyOutputOutput`](crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput).
     pub fn build(self) -> crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput {
         crate::operation::empty_input_and_empty_output::EmptyInputAndEmptyOutputOutput {}
-75
+    }
-76
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/endpoint_operation.rs

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

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

@@ -110,114 +228,239 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "EndpointOperation",
             "Rest Json Protocol",
         ));
-118
         ::std::option::Option::Some(cfg.freeze())
-120
+    }
-121
     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("EndpointOperation")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(EndpointOperationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::endpoint_operation::EndpointOperationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::endpoint_operation::EndpointOperationError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct EndpointOperationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for EndpointOperationResponseDeserializer {
     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))
             })?;
-160
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_endpoint_operation::de_endpoint_operation_http_error(status, headers, body)
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::endpoint_operation::EndpointOperationError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_endpoint_operation::de_endpoint_operation_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, EndpointOperation::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::endpoint_operation::EndpointOperationOutput::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))
-+
+        }
-188
+    }
-189
+}
 #[derive(Debug)]
 struct EndpointOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for EndpointOperationRequestSerializer {
     #[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::endpoint_operation::EndpointOperationInput>()
             .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::endpoint_operation::EndpointOperationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/EndpointOperation").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::endpoint_operation::EndpointOperationInput,
                 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)?;
                 ::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("");
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, EndpointOperation::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-208
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-210
+    }
-211
+}
 #[derive(Debug)]
 struct EndpointOperationEndpointParamsInterceptor;
-214
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EndpointOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EndpointOperationEndpointParamsInterceptor"
-218
+    }
-219

↧ 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::<EndpointOperationInput>()
             .ok_or("failed to downcast to EndpointOperationInput")?;
-234
         let endpoint_prefix = ::aws_smithy_runtime_api::client::endpoint::EndpointPrefix::new("foo.").map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint prefix could not be built", err)
         })?;
         cfg.interceptor_state().store_put(endpoint_prefix);
-239

Client Test

Files changed: