Client Test

rev. 2915cec5ef64cb1ed4992565a748d76a11505b3b (ignoring whitespace)

Files changed:

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

@@ -1,1 +22,78 @@

 // 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 EndpointOperationOutput {}
 static ENDPOINTOPERATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#EndpointOperationOutput",
         "aws.protocoltests.json10.synthetic",
         "EndpointOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
 );
 impl EndpointOperationOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &ENDPOINTOPERATIONOUTPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EndpointOperationOutput {
     #[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(())
-+
+    }
-+
+}
 impl EndpointOperationOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&ENDPOINTOPERATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl EndpointOperationOutput {
     /// 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 EndpointOperationOutput {
     /// Creates a new builder-style object to manufacture [`EndpointOperationOutput`](crate::operation::endpoint_operation::EndpointOperationOutput).
     pub fn builder() -> crate::operation::endpoint_operation::builders::EndpointOperationOutputBuilder {
         crate::operation::endpoint_operation::builders::EndpointOperationOutputBuilder::default()
-66
+    }
-67
+}
-68
 /// A builder for [`EndpointOperationOutput`](crate::operation::endpoint_operation::EndpointOperationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EndpointOperationOutputBuilder {}
 impl EndpointOperationOutputBuilder {
     /// Consumes the builder and constructs a [`EndpointOperationOutput`](crate::operation::endpoint_operation::EndpointOperationOutput).
     pub fn build(self) -> crate::operation::endpoint_operation::EndpointOperationOutput {
         crate::operation::endpoint_operation::EndpointOperationOutput {}
-77
+    }
-78
+}

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/endpoint_with_host_label_operation.rs

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

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

@@ -166,172 +292,304 @@

↥ Expand context

             .filter(|r| !r.is_empty())
         else {
             return ::std::result::Result::Ok(());
         };
-176
         let ::std::option::Option::Some(input) = context.input().downcast_ref::<EndpointWithHostLabelOperationInput>() else {
             // A mismatched input is not this interceptor's concern; skip quietly.
             return ::std::result::Result::Ok(());
         };
-181
         let mut captured = ::aws_smithy_types::telemetry::CapturedTelemetryAttributes::default();
         if requested.should_capture("label") {
             if let ::std::option::Option::Some(value) = input.label.as_deref() {
                 captured.insert("label", value);
-186
+            }
-187
+        }
-188
         cfg.interceptor_state().store_put(captured);
         ::std::result::Result::Ok(())
-191
+    }

-192
+}
 #[derive(Debug)]
 struct EndpointWithHostLabelOperationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for EndpointWithHostLabelOperationResponseDeserializer {
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         // Load body and headers BEFORE BeforeParseResponse so customizations
         // (e.g., S3's `body_is_error` check that detects errors returned with
         // HTTP 200) can inspect them. The legacy non-streaming path also
         // loads `body` before firing this hook.
         let body = response.body().bytes().expect("body loaded");
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut force_error = false;
-210
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_endpoint_with_host_label_operation::de_endpoint_with_host_label_operation_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             #[allow(unused_mut)]
             let mut generic_builder = protocol.parse_error_metadata(response, _cfg).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();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::endpoint_with_host_label_operation::EndpointWithHostLabelOperationError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_endpoint_with_host_label_operation::de_endpoint_with_host_label_operation_http_response(
                 status, headers, body,
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, EndpointWithHostLabelOperation::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             // body and headers are already in scope from the top of the function;
             // alias `headers` as `_response_headers` so MutateOutput
             // customizations have a stable name to read from.
             let _response_headers = headers;
             #[allow(unused_mut)]
             let mut output = crate::operation::endpoint_with_host_label_operation::EndpointWithHostLabelOperationOutput::deserialize_with_response(
                 &mut *deser,
                 _response_headers,
                 response.status().into(),
                 body,
-245
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
             .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))
-+
+        }
-252
+    }
-253
+}
 #[derive(Debug)]
 struct EndpointWithHostLabelOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for EndpointWithHostLabelOperationRequestSerializer {
     #[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_with_host_label_operation::EndpointWithHostLabelOperationInput>()
             .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_with_host_label_operation::EndpointWithHostLabelOperationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::endpoint_with_host_label_operation::EndpointWithHostLabelOperationInput,
                 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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonRpc10.EndpointWithHostLabelOperation",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_endpoint_with_host_label_operation::ser_endpoint_with_host_label_operation_input(&input)?,
         );
         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 request = protocol
             .serialize_request(&input, EndpointWithHostLabelOperation::INPUT_SCHEMA, "/", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-275
+    }
-276
+}
 #[derive(Debug)]
 struct EndpointWithHostLabelOperationEndpointParamsInterceptor;
-279
 #[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EndpointWithHostLabelOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EndpointWithHostLabelOperationEndpointParamsInterceptor"
-284
+    }

↧ Expand context

-285
     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::<EndpointWithHostLabelOperationInput>()
             .ok_or("failed to downcast to EndpointWithHostLabelOperationInput")?;
-300
         let endpoint_prefix = {
             let label = _input.label.as_deref().unwrap_or_default();
             if label.is_empty() {
                 return Err(

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/endpoint_with_host_label_operation/_endpoint_with_host_label_operation_input.rs

@@ -1,1 +44,124 @@

↥ 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 EndpointWithHostLabelOperationInput {
     #[allow(missing_docs)] // documentation missing in model
     pub label: ::std::option::Option<::std::string::String>,
-8
+}
 impl EndpointWithHostLabelOperationInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn label(&self) -> ::std::option::Option<&str> {
         self.label.as_deref()
-13
+    }
-14
+}
 static ENDPOINTWITHHOSTLABELOPERATIONINPUT_MEMBER_LABEL: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#EndpointWithHostLabelOperationInput$label",
         "aws.protocoltests.json10.synthetic",
         "EndpointWithHostLabelOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "label",
 ,
-+
+)
 .with_host_label();
 static ENDPOINTWITHHOSTLABELOPERATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#EndpointWithHostLabelOperationInput",
         "aws.protocoltests.json10.synthetic",
         "EndpointWithHostLabelOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ENDPOINTWITHHOSTLABELOPERATIONINPUT_MEMBER_LABEL],
-+
+)
 .with_payload_hint(::aws_smithy_schema::PayloadHint::NoStructPayload)
 .with_original_name("EndpointWithHostLabelOperationInput");
 impl EndpointWithHostLabelOperationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &ENDPOINTWITHHOSTLABELOPERATIONINPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EndpointWithHostLabelOperationInput {
     #[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.label {
             ser.write_string(&ENDPOINTWITHHOSTLABELOPERATIONINPUT_MEMBER_LABEL, val)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl EndpointWithHostLabelOperationInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&ENDPOINTWITHHOSTLABELOPERATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.label = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.label = builder.label.or(Some(String::new()));
         builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
-+
+    }
-+
+}
 impl EndpointWithHostLabelOperationInput {
     /// 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 EndpointWithHostLabelOperationInput {
     /// Creates a new builder-style object to manufacture [`EndpointWithHostLabelOperationInput`](crate::operation::endpoint_with_host_label_operation::EndpointWithHostLabelOperationInput).
     pub fn builder() -> crate::operation::endpoint_with_host_label_operation::builders::EndpointWithHostLabelOperationInputBuilder {
         crate::operation::endpoint_with_host_label_operation::builders::EndpointWithHostLabelOperationInputBuilder::default()
-99
+    }
-100
+}
-101
 /// A builder for [`EndpointWithHostLabelOperationInput`](crate::operation::endpoint_with_host_label_operation::EndpointWithHostLabelOperationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EndpointWithHostLabelOperationInputBuilder {
     pub(crate) label: ::std::option::Option<::std::string::String>,
-107
+}
 impl EndpointWithHostLabelOperationInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     /// This field is required.
     pub fn label(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.label = ::std::option::Option::Some(input.into());
         self
-114
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_label(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.label = input;
         self
-119
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_label(&self) -> &::std::option::Option<::std::string::String> {
         &self.label
-123
+    }
     /// Consumes the builder and constructs a [`EndpointWithHostLabelOperationInput`](crate::operation::endpoint_with_host_label_operation::EndpointWithHostLabelOperationInput).

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/endpoint_with_host_label_operation/_endpoint_with_host_label_operation_output.rs

@@ -1,1 +22,78 @@

 // 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 EndpointWithHostLabelOperationOutput {}
 static ENDPOINTWITHHOSTLABELOPERATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#EndpointWithHostLabelOperationOutput",
         "aws.protocoltests.json10.synthetic",
         "EndpointWithHostLabelOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
 );
 impl EndpointWithHostLabelOperationOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &ENDPOINTWITHHOSTLABELOPERATIONOUTPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EndpointWithHostLabelOperationOutput {
     #[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(())
-+
+    }
-+
+}
 impl EndpointWithHostLabelOperationOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&ENDPOINTWITHHOSTLABELOPERATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl EndpointWithHostLabelOperationOutput {
     /// 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 EndpointWithHostLabelOperationOutput {
     /// Creates a new builder-style object to manufacture [`EndpointWithHostLabelOperationOutput`](crate::operation::endpoint_with_host_label_operation::EndpointWithHostLabelOperationOutput).
     pub fn builder() -> crate::operation::endpoint_with_host_label_operation::builders::EndpointWithHostLabelOperationOutputBuilder {
         crate::operation::endpoint_with_host_label_operation::builders::EndpointWithHostLabelOperationOutputBuilder::default()
-66
+    }
-67
+}
-68
 /// A builder for [`EndpointWithHostLabelOperationOutput`](crate::operation::endpoint_with_host_label_operation::EndpointWithHostLabelOperationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EndpointWithHostLabelOperationOutputBuilder {}
 impl EndpointWithHostLabelOperationOutputBuilder {
     /// Consumes the builder and constructs a [`EndpointWithHostLabelOperationOutput`](crate::operation::endpoint_with_host_label_operation::EndpointWithHostLabelOperationOutput).
     pub fn build(self) -> crate::operation::endpoint_with_host_label_operation::EndpointWithHostLabelOperationOutput {
         crate::operation::endpoint_with_host_label_operation::EndpointWithHostLabelOperationOutput {}
-77
+    }
-78
+}

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/greeting_with_errors.rs

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

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

@@ -56,60 +115,160 @@

↥ Expand context

             // seven-digit ID for the operation orchestration so that it can be correlated in the logs.
             .instrument(::tracing::debug_span!(
                 "JSON RPC 10.GreetingWithErrors",
                 "rpc.service" = "JSON RPC 10",
                 "rpc.method" = "GreetingWithErrors",
                 "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),
             ))
             .await
-68
+    }
-69
     pub(crate) fn operation_runtime_plugins(
         client_runtime_plugins: ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         client_config: &crate::config::Config,
         config_override: ::std::option::Option<crate::config::Builder>,
     ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
         let mut runtime_plugins = client_runtime_plugins.with_operation_plugin(Self::new());
-76
         if let ::std::option::Option::Some(config_override) = config_override {
             for plugin in config_override.runtime_plugins.iter().cloned() {
                 runtime_plugins = runtime_plugins.with_operation_plugin(plugin);

-80
+            }
             runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(
                 config_override,
                 client_config.config.clone(),
                 &client_config.runtime_components,
             ));
-86
+        }
         runtime_plugins
-88
+    }
-89
+}
 /// Per-operation error registry. Contains an entry for every modeled
 /// error this operation can throw.
 ///
 /// Used by the schema-serde error path as the operation-scoped lookup
 /// for registry-backed error reification: an error code that does not
 /// match one of the operation's modeled errors directly is resolved
 /// against this registry first, then widened to the service-wide error
 /// registry.
 pub(crate) mod error_registry {
     pub(crate) static REGISTRY: ::std::sync::LazyLock<::aws_smithy_schema::registry::TypeRegistry> = ::std::sync::LazyLock::new(|| {
         ::aws_smithy_schema::registry::TypeRegistry::builder()
                             .insert_error_shape(
                         crate::types::error::ComplexError::SCHEMA,
                         |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::aws_smithy_types::type_erasure::TypeErasedBox, ::aws_smithy_schema::serde::SerdeError> {
                             ::std::result::Result::Ok(::aws_smithy_types::type_erasure::TypeErasedBox::new(crate::types::error::ComplexError::deserialize(d)?))
                         },
                         |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync>, ::aws_smithy_schema::serde::SerdeError> {
                             ::std::result::Result::Ok(::std::boxed::Box::new(crate::types::error::ComplexError::deserialize(d)?))
                         },
-+
+                    )
 .insert_error_shape(
                         crate::types::error::FooError::SCHEMA,
                         |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::aws_smithy_types::type_erasure::TypeErasedBox, ::aws_smithy_schema::serde::SerdeError> {
                             ::std::result::Result::Ok(::aws_smithy_types::type_erasure::TypeErasedBox::new(crate::types::error::FooError::deserialize(d)?))
                         },
                         |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync>, ::aws_smithy_schema::serde::SerdeError> {
                             ::std::result::Result::Ok(::std::boxed::Box::new(crate::types::error::FooError::deserialize(d)?))
                         },
-+
+                    )
 .insert_error_shape(
                         crate::types::error::InvalidGreeting::SCHEMA,
                         |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::aws_smithy_types::type_erasure::TypeErasedBox, ::aws_smithy_schema::serde::SerdeError> {
                             ::std::result::Result::Ok(::aws_smithy_types::type_erasure::TypeErasedBox::new(crate::types::error::InvalidGreeting::deserialize(d)?))
                         },
                         |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync>, ::aws_smithy_schema::serde::SerdeError> {
                             ::std::result::Result::Ok(::std::boxed::Box::new(crate::types::error::InvalidGreeting::deserialize(d)?))
                         },
-+
+                    )
                             .build()
     });
-+
+}
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for GreetingWithErrors {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         let mut cfg = ::aws_smithy_types::config_bag::Layer::new("GreetingWithErrors");
-134
         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
             GreetingWithErrorsRequestSerializer,
         ));
         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
             GreetingWithErrorsResponseDeserializer,
         ));

↧ Expand context

-141
         cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
             crate::config::auth::Params::builder()
                 .operation_name("GreetingWithErrors")
                 .build()
                 .expect("required fields set"),
         ));
-148
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "GreetingWithErrors",
             "JSON RPC 10",
         ));
-153
         ::std::option::Option::Some(cfg.freeze())
-155
+    }
-156
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {

@@ -160,205 +283,427 @@

↥ Expand context

             .filter(|r| !r.is_empty())
         else {
             return ::std::result::Result::Ok(());
         };
-209
         let ::std::option::Option::Some(input) = context.input().downcast_ref::<GreetingWithErrorsInput>() else {
             // A mismatched input is not this interceptor's concern; skip quietly.
             return ::std::result::Result::Ok(());
         };
-214
         let mut captured = ::aws_smithy_types::telemetry::CapturedTelemetryAttributes::default();
         if requested.should_capture("greeting") {
             if let ::std::option::Option::Some(value) = input.greeting.as_deref() {
                 captured.insert("greeting", value);
-219
+            }
-220
+        }
-221
         cfg.interceptor_state().store_put(captured);
         ::std::result::Result::Ok(())
-224
+    }

-225
+}
 #[derive(Debug)]
 struct GreetingWithErrorsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GreetingWithErrorsResponseDeserializer {
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         // Load body and headers BEFORE BeforeParseResponse so customizations
         // (e.g., S3's `body_is_error` check that detects errors returned with
         // HTTP 200) can inspect them. The legacy non-streaming path also
         // loads `body` before firing this hook.
         let body = response.body().bytes().expect("body loaded");
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut force_error = false;
-243
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_response(status, headers, body)
         if !success && status != 200 || force_error {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             #[allow(unused_mut)]
             let mut generic_builder = protocol.parse_error_metadata(response, _cfg).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::greeting_with_errors::GreetingWithErrorsError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let err = match error_code {
                 "InvalidGreeting" => crate::operation::greeting_with_errors::GreetingWithErrorsError::InvalidGreeting({
                     let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
                         crate::types::error::InvalidGreeting::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ComplexError" => crate::operation::greeting_with_errors::GreetingWithErrorsError::ComplexError({
                     let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
                         crate::types::error::ComplexError::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
                 }),
                 "FooError" => crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError({
                     let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
                         crate::types::error::FooError::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
                 }),
                 _ => {
                     // Registry-backed, operation-scoped reification of an error whose
                     // code this operation does not model directly: the operation's own
                     // error registry is consulted first, then the lookup widens to the
                     // service-wide error registry. On a hit, the reified error is attached
                     // as the source of the returned unhandled error while its metadata
                     // (code, message, request id) is preserved; on a miss the generic
                     // error is returned unchanged.
                     match protocol
                         .deserialize_error_response(response, _cfg)
                         .ok()
                         .and_then(|mut deser| {
                             ::aws_smithy_schema::registry::reify_error(
                                 crate::operation::greeting_with_errors::error_registry::REGISTRY
                                     .or(&crate::error_type_registry::REGISTRY),
                                 error_code,
                                 &mut *deser,
-+
+                            )
                         }) {
                         ::std::option::Option::Some(source) => <crate::operation::greeting_with_errors::GreetingWithErrorsError as ::aws_smithy_runtime_api::client::result::CreateUnhandledError>::create_unhandled_error(source, ::std::option::Option::Some(generic)),
                         ::std::option::Option::None => crate::operation::greeting_with_errors::GreetingWithErrorsError::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, GreetingWithErrors::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             // body and headers are already in scope from the top of the function;
             // alias `headers` as `_response_headers` so MutateOutput
             // customizations have a stable name to read from.
             let _response_headers = headers;
             #[allow(unused_mut)]
             let mut output = crate::operation::greeting_with_errors::GreetingWithErrorsOutput::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))
-+
+        }
-375
+    }
-376
+}
 #[derive(Debug)]
 struct GreetingWithErrorsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GreetingWithErrorsRequestSerializer {
     #[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::greeting_with_errors::GreetingWithErrorsInput>()
             .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::greeting_with_errors::GreetingWithErrorsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::greeting_with_errors::GreetingWithErrorsInput,
                 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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonRpc10.GreetingWithErrors",
             );
             builder
         };
         let body =
             ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_greeting_with_errors::ser_greeting_with_errors_input(&input)?);
         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 request = protocol
             .serialize_request(&input, GreetingWithErrors::INPUT_SCHEMA, "/", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-398
+    }
-399
+}
 #[derive(Debug)]
 struct GreetingWithErrorsEndpointParamsInterceptor;
-402
 #[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GreetingWithErrorsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GreetingWithErrorsEndpointParamsInterceptor"
-407
+    }

↧ Expand context

-408
     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::<GreetingWithErrorsInput>()
             .ok_or("failed to downcast to GreetingWithErrorsInput")?;
-423
         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()

@@ -296,440 +995,1237 @@

↥ Expand context

     /// Parses simple JSON errors
     /// Test ID: AwsJson10InvalidGreetingError
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_invalid_greeting_error_response() {
         let expected_output = crate::types::error::InvalidGreeting::builder()
             .set_message(::std::option::Option::Some("Hi".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(400)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"__type\": \"aws.protocoltests.json10#InvalidGreeting\",\n    \"Message\": \"Hi\"\n}",
                 ))
                 .unwrap(),
-456
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;

-460
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-466
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-477
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::InvalidGreeting(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-495
+        }
-496
+    }
-497
     /// Parses a complex error with no message member
     /// Test ID: AwsJson10ComplexError
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_complex_error_response() {
         let expected_output = crate::types::error::ComplexError::builder()
             .set_top_level(::std::option::Option::Some("Top level".to_owned()))
             .set_nested(::std::option::Option::Some(
                 crate::types::ComplexNestedErrorData::builder()
                     .set_foo(::std::option::Option::Some("bar".to_owned()))
                     .build(),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "application/x-amz-json-1.0")
         .status(400)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"__type\": \"aws.protocoltests.json10#ComplexError\",\n    \"TopLevel\": \"Top level\",\n    \"Nested\": {\n        \"Foo\": \"bar\"\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-519
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-525
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-536
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::ComplexError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.top_level, expected_output.top_level, "Unexpected value for `top_level`");
             ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-556
+        }
-557
+    }
-558
     /// Parses a complex error with an empty body
     /// Test ID: AwsJson10EmptyComplexError
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_empty_complex_error_response() {
         let expected_output = crate::types::error::ComplexError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(400)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"__type\": \"aws.protocoltests.json10#ComplexError\"\n}",
                 ))
                 .unwrap(),
-573
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-577
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-583
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-594
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::ComplexError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.top_level, expected_output.top_level, "Unexpected value for `top_level`");
             ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-614
+        }
-615
+    }
-616
     /// Serializes the X-Amzn-ErrorType header. For an example service, see Amazon EKS.
     /// Test ID: AwsJson10FooErrorUsingXAmznErrorType
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_foo_error_using_x_amzn_error_type_response() {
         let expected_output = crate::types::error::FooError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("X-Amzn-Errortype", "FooError")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-629
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-633
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-639
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-650
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-668
+        }
-669
+    }
-670
     /// Some X-Amzn-Errortype headers contain URLs. Clients need to split the URL on ':' and take only the first half of the string. For example, 'ValidationException:http://internal.amazon.com/coral/com.amazon.coral.validate/'
     /// is to be interpreted as 'ValidationException'.
     ///
     /// For an example service see Amazon Polly.
     /// Test ID: AwsJson10FooErrorUsingXAmznErrorTypeWithUri
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_foo_error_using_x_amzn_error_type_with_uri_response() {
         let expected_output = crate::types::error::FooError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("X-Amzn-Errortype", "FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-686
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-690
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-696
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-707
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-725
+        }
-726
+    }
-727
     /// X-Amzn-Errortype might contain a URL and a namespace. Client should extract only the shape name. This is a pathalogical case that might not actually happen in any deployed AWS service.
     /// Test ID: AwsJson10FooErrorUsingXAmznErrorTypeWithUriAndNamespace
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_foo_error_using_x_amzn_error_type_with_uri_and_namespace_response() {
         let expected_output = crate::types::error::FooError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header(
                     "X-Amzn-Errortype",
                     "aws.protocoltests.json10#FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/",
-739
+                )
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-743
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-747
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-753
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-764
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-782
+        }
-783
+    }
-784
     /// This example uses the 'code' property in the output rather than X-Amzn-Errortype. Some services do this though it's preferable to send the X-Amzn-Errortype. Client implementations must first check for the X-Amzn-Errortype and then check for a top-level 'code' property.
     ///
     /// For example service see Amazon S3 Glacier.
     /// Test ID: AwsJson10FooErrorUsingCode
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_foo_error_using_code_response() {
         let expected_output = crate::types::error::FooError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"code\": \"FooError\"\n}"))
                 .unwrap(),
-799
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-803
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-809
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-820
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-838
+        }
-839
+    }
-840
     /// Some services serialize errors using code, and it might contain a namespace. Clients should just take the last part of the string after '#'.
     /// Test ID: AwsJson10FooErrorUsingCodeAndNamespace
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_foo_error_using_code_and_namespace_response() {
         let expected_output = crate::types::error::FooError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"code\": \"aws.protocoltests.json10#FooError\"\n}",
                 ))
                 .unwrap(),
-855
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-859
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-865
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-876
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-894
+        }
-895
+    }
-896
     /// Some services serialize errors using code, and it might contain a namespace. It also might contain a URI. Clients should just take the last part of the string after '#' and before ":". This is a pathalogical case that might not occur in any deployed AWS service.
     /// Test ID: AwsJson10FooErrorUsingCodeUriAndNamespace
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_foo_error_using_code_uri_and_namespace_response() {
         let expected_output = crate::types::error::FooError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"code\": \"aws.protocoltests.json10#FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/\"\n}",
                 ))
                 .unwrap(),
-911
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-915
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-921
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-932
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-950
+        }
-951
+    }
-952
     /// Some services serialize errors using __type.
     /// Test ID: AwsJson10FooErrorWithDunderType
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_foo_error_with_dunder_type_response() {
         let expected_output = crate::types::error::FooError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"__type\": \"FooError\"\n}"))
                 .unwrap(),
-965
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-969
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-975
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-986
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-1004
+        }
-1005
+    }
-1006
     /// Some services serialize errors using __type, and it might contain a namespace. Clients should just take the last part of the string after '#'.
     /// Test ID: AwsJson10FooErrorWithDunderTypeAndNamespace
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_foo_error_with_dunder_type_and_namespace_response() {
         let expected_output = crate::types::error::FooError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"__type\": \"aws.protocoltests.json10#FooError\"\n}",
                 ))
                 .unwrap(),
-1021
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1025
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-1031
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-1042
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-1060
+        }
-1061
+    }
-1062
     /// Because only the part after '#' is considered, an unrecognized namespace should not make a difference.
     /// Test ID: AwsJson10FooErrorWithDunderTypeAndDifferentNamespace
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_foo_error_with_dunder_type_and_different_namespace_response() {
         let expected_output = crate::types::error::FooError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"__type\": \"aws.different.namespace#FooError\"\n}",
                 ))
                 .unwrap(),
-1077
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1081
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-1087
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-1098
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-1116
+        }
-1117
+    }
-1118
     /// Some services serialize errors using __type, and it might contain a namespace. It also might contain a URI. Clients should just take the last part of the string after '#' and before ":". This is a pathalogical case that might not occur in any deployed AWS service.
     /// Test ID: AwsJson10FooErrorWithDunderTypeUriAndNamespace
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_foo_error_with_dunder_type_uri_and_namespace_response() {
         let expected_output = crate::types::error::FooError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"__type\": \"aws.protocoltests.json10#FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/\"\n}",
                 ))
                 .unwrap(),
-1133
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1137
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-1143
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-1154
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-1172
+        }
-1173
+    }
-1174
     /// Some services serialize errors using __type, and if the response includes additional shapes that belong to a different namespace there'll be a nested __type property that must not be considered when determining which error to be surfaced.
     ///
     /// For an example service see Amazon DynamoDB.
     /// Test ID: AwsJson10FooErrorWithNestedTypeProperty
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_foo_error_with_nested_type_property_response() {
         let expected_output = crate::types::error::FooError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "application/x-amz-json-1.0")
         .status(500)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"__type\": \"aws.protocoltests.json10#FooError\",\n    \"ErrorDetails\": [\n      {\n          \"__type\": \"com.amazon.internal#ErrorDetails\",\n          \"reason\": \"Some reason\"\n      }\n    ]\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1191
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-1197
         // 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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-1208
         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_with_config(&http_response, &test_cfg)

↧ Expand context

         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-1226
+        }
-1227
+    }
-1228
+}
-1229
 /// Error type for the `GreetingWithErrorsError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum GreetingWithErrorsError {
     /// This error is thrown when an invalid greeting value is provided.
     InvalidGreeting(crate::types::error::InvalidGreeting),
     /// This error is thrown when a request is invalid.
     ComplexError(crate::types::error::ComplexError),

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/greeting_with_errors/_greeting_with_errors_input.rs

@@ -1,1 +44,122 @@

↥ 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 GreetingWithErrorsInput {
     #[allow(missing_docs)] // documentation missing in model
     pub greeting: ::std::option::Option<::std::string::String>,
-8
+}
 impl GreetingWithErrorsInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn greeting(&self) -> ::std::option::Option<&str> {
         self.greeting.as_deref()
-13
+    }
-14
+}
 static GREETINGWITHERRORSINPUT_MEMBER_GREETING: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#GreetingWithErrorsInput$greeting",
         "aws.protocoltests.json10.synthetic",
         "GreetingWithErrorsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "greeting",
 ,
 );
 static GREETINGWITHERRORSINPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#GreetingWithErrorsInput",
         "aws.protocoltests.json10.synthetic",
         "GreetingWithErrorsInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GREETINGWITHERRORSINPUT_MEMBER_GREETING],
-+
+)
 .with_payload_hint(::aws_smithy_schema::PayloadHint::NoStructPayload)
 .with_original_name("GreetingWithErrorsInput");
 impl GreetingWithErrorsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &GREETINGWITHERRORSINPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GreetingWithErrorsInput {
     #[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.greeting {
             ser.write_string(&GREETINGWITHERRORSINPUT_MEMBER_GREETING, val)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl GreetingWithErrorsInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&GREETINGWITHERRORSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.greeting = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
-+
+    }
-+
+}
 impl GreetingWithErrorsInput {
     /// 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 GreetingWithErrorsInput {
     /// Creates a new builder-style object to manufacture [`GreetingWithErrorsInput`](crate::operation::greeting_with_errors::GreetingWithErrorsInput).
     pub fn builder() -> crate::operation::greeting_with_errors::builders::GreetingWithErrorsInputBuilder {
         crate::operation::greeting_with_errors::builders::GreetingWithErrorsInputBuilder::default()
-97
+    }
-98
+}
-99
 /// A builder for [`GreetingWithErrorsInput`](crate::operation::greeting_with_errors::GreetingWithErrorsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GreetingWithErrorsInputBuilder {
     pub(crate) greeting: ::std::option::Option<::std::string::String>,
-105
+}
 impl GreetingWithErrorsInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn greeting(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.greeting = ::std::option::Option::Some(input.into());
         self
-111
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_greeting(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.greeting = input;
         self
-116
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_greeting(&self) -> &::std::option::Option<::std::string::String> {
         &self.greeting
-120
+    }
     /// Consumes the builder and constructs a [`GreetingWithErrorsInput`](crate::operation::greeting_with_errors::GreetingWithErrorsInput).
     pub fn build(

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/greeting_with_errors/_greeting_with_errors_output.rs

@@ -1,1 +44,121 @@

↥ 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 GreetingWithErrorsOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub greeting: ::std::option::Option<::std::string::String>,
-8
+}
 impl GreetingWithErrorsOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn greeting(&self) -> ::std::option::Option<&str> {
         self.greeting.as_deref()
-13
+    }
-14
+}
 static GREETINGWITHERRORSOUTPUT_MEMBER_GREETING: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#GreetingWithErrorsOutput$greeting",
         "aws.protocoltests.json10.synthetic",
         "GreetingWithErrorsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "greeting",
 ,
 );
 static GREETINGWITHERRORSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#GreetingWithErrorsOutput",
         "aws.protocoltests.json10.synthetic",
         "GreetingWithErrorsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GREETINGWITHERRORSOUTPUT_MEMBER_GREETING],
-+
+)
 .with_original_name("GreetingWithErrorsOutput");
 impl GreetingWithErrorsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &GREETINGWITHERRORSOUTPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GreetingWithErrorsOutput {
     #[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.greeting {
             ser.write_string(&GREETINGWITHERRORSOUTPUT_MEMBER_GREETING, val)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl GreetingWithErrorsOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&GREETINGWITHERRORSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.greeting = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl GreetingWithErrorsOutput {
     /// 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 GreetingWithErrorsOutput {
     /// Creates a new builder-style object to manufacture [`GreetingWithErrorsOutput`](crate::operation::greeting_with_errors::GreetingWithErrorsOutput).
     pub fn builder() -> crate::operation::greeting_with_errors::builders::GreetingWithErrorsOutputBuilder {
         crate::operation::greeting_with_errors::builders::GreetingWithErrorsOutputBuilder::default()
-96
+    }
-97
+}
-98
 /// A builder for [`GreetingWithErrorsOutput`](crate::operation::greeting_with_errors::GreetingWithErrorsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GreetingWithErrorsOutputBuilder {
     pub(crate) greeting: ::std::option::Option<::std::string::String>,
-104
+}
 impl GreetingWithErrorsOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn greeting(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.greeting = ::std::option::Option::Some(input.into());
         self
-110
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_greeting(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.greeting = input;
         self
-115
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_greeting(&self) -> &::std::option::Option<::std::string::String> {
         &self.greeting
-119
+    }
     /// Consumes the builder and constructs a [`GreetingWithErrorsOutput`](crate::operation::greeting_with_errors::GreetingWithErrorsOutput).
     pub fn build(self) -> crate::operation::greeting_with_errors::GreetingWithErrorsOutput {

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/host_with_path_operation.rs

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

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

@@ -114,120 +235,252 @@

↥ Expand context

         _: &::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("HostWithPathOperation")
             .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
                 ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
             ))
             .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
                 HostWithPathOperationEndpointParamsInterceptor,
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::host_with_path_operation::HostWithPathOperationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::host_with_path_operation::HostWithPathOperationError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}

-140
 #[derive(Debug)]
 struct HostWithPathOperationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HostWithPathOperationResponseDeserializer {
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         // Load body and headers BEFORE BeforeParseResponse so customizations
         // (e.g., S3's `body_is_error` check that detects errors returned with
         // HTTP 200) can inspect them. The legacy non-streaming path also
         // loads `body` before firing this hook.
         let body = response.body().bytes().expect("body loaded");
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut force_error = false;
-158
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_host_with_path_operation::de_host_with_path_operation_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             #[allow(unused_mut)]
             let mut generic_builder = protocol.parse_error_metadata(response, _cfg).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();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::host_with_path_operation::HostWithPathOperationError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_host_with_path_operation::de_host_with_path_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, HostWithPathOperation::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             // body and headers are already in scope from the top of the function;
             // alias `headers` as `_response_headers` so MutateOutput
             // customizations have a stable name to read from.
             let _response_headers = headers;
             #[allow(unused_mut)]
             let mut output = crate::operation::host_with_path_operation::HostWithPathOperationOutput::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))
-+
+        }
-200
+    }
-201
+}
 #[derive(Debug)]
 struct HostWithPathOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for HostWithPathOperationRequestSerializer {
     #[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::host_with_path_operation::HostWithPathOperationInput>()
             .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::host_with_path_operation::HostWithPathOperationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::host_with_path_operation::HostWithPathOperationInput,
                 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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonRpc10.HostWithPathOperation",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_host_with_path_operation::ser_host_with_path_operation_input(&input)?,
         );
-214
         ::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 request = protocol
             .serialize_request(&input, HostWithPathOperation::INPUT_SCHEMA, "/", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-223
+    }
-224
+}
 #[derive(Debug)]
 struct HostWithPathOperationEndpointParamsInterceptor;
-227
 #[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HostWithPathOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HostWithPathOperationEndpointParamsInterceptor"
-232
+    }

↧ Expand context

-233
     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::<HostWithPathOperationInput>()
             .ok_or("failed to downcast to HostWithPathOperationInput")?;
-248
         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()

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/host_with_path_operation/_host_with_path_operation_input.rs

@@ -1,1 +25,85 @@

 // 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 HostWithPathOperationInput {}
 static HOSTWITHPATHOPERATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#HostWithPathOperationInput",
         "aws.protocoltests.json10.synthetic",
         "HostWithPathOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
-+
+)
 .with_no_body_members()
 .with_payload_hint(::aws_smithy_schema::PayloadHint::NoStructPayload);
 impl HostWithPathOperationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &HOSTWITHPATHOPERATIONINPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HostWithPathOperationInput {
     #[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(())
-+
+    }
-+
+}
 impl HostWithPathOperationInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&HOSTWITHPATHOPERATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
-+
+    }
-+
+}
 impl HostWithPathOperationInput {
     /// 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(e.to_string()))
-+
+    }
-+
+}
 impl HostWithPathOperationInput {
     /// Creates a new builder-style object to manufacture [`HostWithPathOperationInput`](crate::operation::host_with_path_operation::HostWithPathOperationInput).
     pub fn builder() -> crate::operation::host_with_path_operation::builders::HostWithPathOperationInputBuilder {
         crate::operation::host_with_path_operation::builders::HostWithPathOperationInputBuilder::default()
-70
+    }
-71
+}
-72
 /// A builder for [`HostWithPathOperationInput`](crate::operation::host_with_path_operation::HostWithPathOperationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/host_with_path_operation/_host_with_path_operation_output.rs

@@ -1,1 +22,78 @@

 // 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 HostWithPathOperationOutput {}
 static HOSTWITHPATHOPERATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#HostWithPathOperationOutput",
         "aws.protocoltests.json10.synthetic",
         "HostWithPathOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
 );
 impl HostWithPathOperationOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &HOSTWITHPATHOPERATIONOUTPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HostWithPathOperationOutput {
     #[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(())
-+
+    }
-+
+}
 impl HostWithPathOperationOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&HOSTWITHPATHOPERATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl HostWithPathOperationOutput {
     /// 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 HostWithPathOperationOutput {
     /// Creates a new builder-style object to manufacture [`HostWithPathOperationOutput`](crate::operation::host_with_path_operation::HostWithPathOperationOutput).
     pub fn builder() -> crate::operation::host_with_path_operation::builders::HostWithPathOperationOutputBuilder {
         crate::operation::host_with_path_operation::builders::HostWithPathOperationOutputBuilder::default()
-66
+    }
-67
+}
-68
 /// A builder for [`HostWithPathOperationOutput`](crate::operation::host_with_path_operation::HostWithPathOperationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HostWithPathOperationOutputBuilder {}
 impl HostWithPathOperationOutputBuilder {
     /// Consumes the builder and constructs a [`HostWithPathOperationOutput`](crate::operation::host_with_path_operation::HostWithPathOperationOutput).
     pub fn build(self) -> crate::operation::host_with_path_operation::HostWithPathOperationOutput {
         crate::operation::host_with_path_operation::HostWithPathOperationOutput {}
-77
+    }
-78
+}

Pages: 1 2 3 4 5 6 7 8 9 10