Client Test

Client Test

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406 (ignoring whitespace)

Files changed:

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

@@ -1,1 +109,130 @@
   17     17   
    "aws.protocoltests.restjson.synthetic",
   18     18   
    "TestGetNoPayloadInput",
   19     19   
);
   20     20   
static TESTGETNOPAYLOADINPUT_MEMBER_TEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   21     21   
    ::aws_smithy_schema::ShapeId::from_static(
   22     22   
        "aws.protocoltests.restjson.synthetic#TestGetNoPayloadInput$testId",
   23     23   
        "aws.protocoltests.restjson.synthetic",
   24     24   
        "TestGetNoPayloadInput",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "test_id",
          27  +
    "testId",
   28     28   
    0,
   29     29   
)
   30     30   
.with_http_header("X-Amz-Test-Id");
   31     31   
static TESTGETNOPAYLOADINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    TESTGETNOPAYLOADINPUT_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&TESTGETNOPAYLOADINPUT_MEMBER_TEST_ID],
   35         -
);
          35  +
)
          36  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/no_payload", None));
   36     37   
impl TestGetNoPayloadInput {
   37     38   
    /// The schema for this shape.
   38     39   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTGETNOPAYLOADINPUT_SCHEMA;
   39     40   
}
   40     41   
impl ::aws_smithy_schema::serde::SerializableStruct for TestGetNoPayloadInput {
   41     42   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     43   
    fn serialize_members(
   43     44   
        &self,
   44     45   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     46   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     47   
        if let Some(ref val) = self.test_id {
   47     48   
            ser.write_string(&TESTGETNOPAYLOADINPUT_MEMBER_TEST_ID, val)?;
   48     49   
        }
   49     50   
        Ok(())
   50     51   
    }
   51     52   
}
   52     53   
impl TestGetNoPayloadInput {
   53     54   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          55  +
    pub fn deserialize(
          56  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     57   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     58   
        #[allow(unused_variables, unused_mut)]
   58     59   
        let mut builder = Self::builder();
   59     60   
        #[allow(
   60     61   
            unused_variables,
   61     62   
            unreachable_code,
   62     63   
            clippy::single_match,
   63     64   
            clippy::match_single_binding,
   64     65   
            clippy::diverging_sub_expression
   65     66   
        )]
   66         -
        deserializer.read_struct(&TESTGETNOPAYLOADINPUT_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&TESTGETNOPAYLOADINPUT_SCHEMA, &mut |member, deser| {
   67     68   
            match member.member_index() {
   68     69   
                Some(0) => {
   69     70   
                    builder.test_id = Some(deser.read_string(member)?);
   70     71   
                }
   71     72   
                _ => {}
   72     73   
            }
   73     74   
            Ok(())
   74     75   
        })?;
   75     76   
        builder
   76     77   
            .build()
   77     78   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   78     79   
    }
   79     80   
}
          81  +
impl TestGetNoPayloadInput {
          82  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          83  +
    /// Header-bound members are read directly from headers, avoiding runtime
          84  +
    /// member iteration overhead. Body members are read via the deserializer.
          85  +
    pub fn deserialize_with_response(
          86  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          87  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          88  +
        _status: u16,
          89  +
        _body: &[u8],
          90  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          91  +
        #[allow(unused_variables, unused_mut)]
          92  +
        let mut builder = Self::builder();
          93  +
        if let Some(val) = headers.get("X-Amz-Test-Id") {
          94  +
            builder.test_id = Some(val.to_string());
          95  +
        }
          96  +
        builder
          97  +
            .build()
          98  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
          99  +
    }
         100  +
}
   80    101   
impl TestGetNoPayloadInput {
   81    102   
    /// Creates a new builder-style object to manufacture [`TestGetNoPayloadInput`](crate::operation::test_get_no_payload::TestGetNoPayloadInput).
   82    103   
    pub fn builder() -> crate::operation::test_get_no_payload::builders::TestGetNoPayloadInputBuilder {
   83    104   
        crate::operation::test_get_no_payload::builders::TestGetNoPayloadInputBuilder::default()
   84    105   
    }
   85    106   
}
   86    107   
   87    108   
/// A builder for [`TestGetNoPayloadInput`](crate::operation::test_get_no_payload::TestGetNoPayloadInput).
   88    109   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   89    110   
#[non_exhaustive]

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

@@ -1,1 +107,125 @@
   17     17   
    "aws.protocoltests.restjson.synthetic",
   18     18   
    "TestGetNoPayloadOutput",
   19     19   
);
   20     20   
static TESTGETNOPAYLOADOUTPUT_MEMBER_TEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   21     21   
    ::aws_smithy_schema::ShapeId::from_static(
   22     22   
        "aws.protocoltests.restjson.synthetic#TestGetNoPayloadOutput$testId",
   23     23   
        "aws.protocoltests.restjson.synthetic",
   24     24   
        "TestGetNoPayloadOutput",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "test_id",
          27  +
    "testId",
   28     28   
    0,
   29     29   
)
   30     30   
.with_http_header("X-Amz-Test-Id");
   31     31   
static TESTGETNOPAYLOADOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    TESTGETNOPAYLOADOUTPUT_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&TESTGETNOPAYLOADOUTPUT_MEMBER_TEST_ID],
   35     35   
);
   36     36   
impl TestGetNoPayloadOutput {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTGETNOPAYLOADOUTPUT_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for TestGetNoPayloadOutput {
   41     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     42   
    fn serialize_members(
   43     43   
        &self,
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        if let Some(ref val) = self.test_id {
   47     47   
            ser.write_string(&TESTGETNOPAYLOADOUTPUT_MEMBER_TEST_ID, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl TestGetNoPayloadOutput {
   53     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     57   
        #[allow(unused_variables, unused_mut)]
   58     58   
        let mut builder = Self::builder();
   59     59   
        #[allow(
   60     60   
            unused_variables,
   61     61   
            unreachable_code,
   62     62   
            clippy::single_match,
   63     63   
            clippy::match_single_binding,
   64     64   
            clippy::diverging_sub_expression
   65     65   
        )]
   66         -
        deserializer.read_struct(&TESTGETNOPAYLOADOUTPUT_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&TESTGETNOPAYLOADOUTPUT_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.test_id = Some(deser.read_string(member)?);
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl TestGetNoPayloadOutput {
          79  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          80  +
    /// Header-bound members are read directly from headers, avoiding runtime
          81  +
    /// member iteration overhead. Body members are read via the deserializer.
          82  +
    pub fn deserialize_with_response(
          83  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          84  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          85  +
        _status: u16,
          86  +
        _body: &[u8],
          87  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          88  +
        #[allow(unused_variables, unused_mut)]
          89  +
        let mut builder = Self::builder();
          90  +
        if let Some(val) = headers.get("X-Amz-Test-Id") {
          91  +
            builder.test_id = Some(val.to_string());
          92  +
        }
          93  +
        Ok(builder.build())
          94  +
    }
          95  +
}
   78     96   
impl TestGetNoPayloadOutput {
   79     97   
    /// Creates a new builder-style object to manufacture [`TestGetNoPayloadOutput`](crate::operation::test_get_no_payload::TestGetNoPayloadOutput).
   80     98   
    pub fn builder() -> crate::operation::test_get_no_payload::builders::TestGetNoPayloadOutputBuilder {
   81     99   
        crate::operation::test_get_no_payload::builders::TestGetNoPayloadOutputBuilder::default()
   82    100   
    }
   83    101   
}
   84    102   
   85    103   
/// A builder for [`TestGetNoPayloadOutput`](crate::operation::test_get_no_payload::TestGetNoPayloadOutput).
   86    104   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   87    105   
#[non_exhaustive]

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

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `TestPayloadBlob`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct TestPayloadBlob;
    6      6   
impl TestPayloadBlob {
    7      7   
    /// Creates a new `TestPayloadBlob`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::test_payload_blob::TestPayloadBlobInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::test_payload_blob::TestPayloadBlobOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::test_payload_blob::TestPayloadBlobInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::test_payload_blob::TestPayloadBlobOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::test_payload_blob::TestPayloadBlobError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -110,114 +233,250 @@
  130    134   
                crate::operation::test_payload_blob::TestPayloadBlobError,
  131    135   
            >::new());
  132    136   
  133    137   
        ::std::borrow::Cow::Owned(rcb)
  134    138   
    }
  135    139   
}
  136    140   
  137    141   
#[derive(Debug)]
  138    142   
struct TestPayloadBlobResponseDeserializer;
  139    143   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for TestPayloadBlobResponseDeserializer {
  140         -
    fn deserialize_nonstreaming(
         144  +
    fn deserialize_nonstreaming_with_config(
  141    145   
        &self,
  142    146   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         147  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  143    148   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  144    149   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
         150  +
        #[allow(unused_mut)]
         151  +
        let mut force_error = false;
         152  +
         153  +
        if !success && status != 200 || force_error {
  145    154   
            let headers = response.headers();
  146    155   
            let body = response.body().bytes().expect("body loaded");
  147    156   
            #[allow(unused_mut)]
  148         -
        let mut force_error = false;
         157  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         158  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         159  +
            })?;
  149    160   
  150         -
        let parse_result = if !success && status != 200 || force_error {
  151         -
            crate::protocol_serde::shape_test_payload_blob::de_test_payload_blob_http_error(status, headers, body)
         161  +
            let generic = generic_builder.build();
         162  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         163  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
         164  +
                    crate::operation::test_payload_blob::TestPayloadBlobError::generic(generic),
         165  +
                ),
         166  +
            ))
  152    167   
        } else {
  153         -
            crate::protocol_serde::shape_test_payload_blob::de_test_payload_blob_http_response(status, headers, body)
  154         -
        };
  155         -
        crate::protocol_serde::type_erase_result(parse_result)
         168  +
            let protocol = _cfg
         169  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         170  +
                .expect("a SharedClientProtocol is required");
         171  +
            let mut deser = protocol
         172  +
                .deserialize_response(response, TestPayloadBlob::OUTPUT_SCHEMA, _cfg)
         173  +
                .map_err(|e| {
         174  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         175  +
                })?;
         176  +
            let body = response.body().bytes().expect("body loaded");
         177  +
            let output = crate::operation::test_payload_blob::TestPayloadBlobOutput::deserialize_with_response(
         178  +
                &mut *deser,
         179  +
                response.headers(),
         180  +
                response.status().into(),
         181  +
                body,
         182  +
            )
         183  +
            .map_err(|e| {
         184  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         185  +
            })?;
         186  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         187  +
        }
  156    188   
    }
  157    189   
}
  158    190   
#[derive(Debug)]
  159    191   
struct TestPayloadBlobRequestSerializer;
  160    192   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for TestPayloadBlobRequestSerializer {
  161    193   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  162    194   
    fn serialize_input(
  163    195   
        &self,
  164    196   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  165    197   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  166    198   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  167    199   
        let input = input
  168    200   
            .downcast::<crate::operation::test_payload_blob::TestPayloadBlobInput>()
  169    201   
            .expect("correct type");
  170         -
        let _header_serialization_settings = _cfg
  171         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  172         -
            .cloned()
  173         -
            .unwrap_or_default();
  174         -
        let mut request_builder = {
  175         -
            #[allow(clippy::uninlined_format_args)]
  176         -
            fn uri_base(
  177         -
                _input: &crate::operation::test_payload_blob::TestPayloadBlobInput,
  178         -
                output: &mut ::std::string::String,
  179         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  180         -
                use ::std::fmt::Write as _;
  181         -
                ::std::write!(output, "/blob_payload").expect("formatting should succeed");
  182         -
                ::std::result::Result::Ok(())
         202  +
        let protocol = _cfg
         203  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         204  +
            .expect("a SharedClientProtocol is required");
         205  +
        let mut input = input;
         206  +
        let payload = input.data.take();
         207  +
        let mut request = protocol
         208  +
            .serialize_request(&input, TestPayloadBlob::INPUT_SCHEMA, "", _cfg)
         209  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         210  +
        if let ::std::option::Option::Some(payload) = payload {
         211  +
            *request.body_mut() = ::aws_smithy_types::body::SdkBody::from(payload.into_inner());
         212  +
            if !request.headers().contains_key("Content-Type") {
         213  +
                request.headers_mut().insert("Content-Type", "application/octet-stream");
         214  +
            }
         215  +
            if let ::std::option::Option::Some(content_length) = request.body().content_length() {
         216  +
                request.headers_mut().insert("Content-Length", content_length.to_string());
  183    217   
            }
  184         -
            #[allow(clippy::unnecessary_wraps)]
  185         -
            fn update_http_builder(
  186         -
                input: &crate::operation::test_payload_blob::TestPayloadBlobInput,
  187         -
                builder: ::http_1x::request::Builder,
  188         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  189         -
                let mut uri = ::std::string::String::new();
  190         -
                uri_base(input, &mut uri)?;
  191         -
                let builder = crate::protocol_serde::shape_test_payload_blob::ser_test_payload_blob_headers(input, builder)?;
  192         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  193         -
            }
  194         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  195         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
  196         -
            builder
  197         -
        };
  198         -
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_test_payload_blob_input::ser_data_http_payload(input.data)?);
  199         -
        if let Some(content_length) = body.content_length() {
  200         -
            let content_length = content_length.to_string();
  201         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  202    218   
        }
  203         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         219  +
         220  +
        return ::std::result::Result::Ok(request);
  204    221   
    }
  205    222   
}
  206    223   
#[derive(Debug)]
  207    224   
struct TestPayloadBlobEndpointParamsInterceptor;
  208    225   
  209    226   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TestPayloadBlobEndpointParamsInterceptor {
  210    227   
    fn name(&self) -> &'static str {
  211    228   
        "TestPayloadBlobEndpointParamsInterceptor"
  212    229   
    }
  213    230

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

@@ -3,3 +132,156 @@
   23     23   
    "aws.protocoltests.restjson.synthetic",
   24     24   
    "TestPayloadBlobInput",
   25     25   
);
   26     26   
static TESTPAYLOADBLOBINPUT_MEMBER_CONTENT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static(
   28     28   
        "aws.protocoltests.restjson.synthetic#TestPayloadBlobInput$contentType",
   29     29   
        "aws.protocoltests.restjson.synthetic",
   30     30   
        "TestPayloadBlobInput",
   31     31   
    ),
   32     32   
    ::aws_smithy_schema::ShapeType::String,
   33         -
    "content_type",
          33  +
    "contentType",
   34     34   
    0,
   35     35   
)
   36     36   
.with_http_header("Content-Type");
   37     37   
static TESTPAYLOADBLOBINPUT_MEMBER_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "aws.protocoltests.restjson.synthetic#TestPayloadBlobInput$data",
   40     40   
        "aws.protocoltests.restjson.synthetic",
   41     41   
        "TestPayloadBlobInput",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Blob,
   44     44   
    "data",
   45     45   
    1,
   46     46   
)
   47     47   
.with_http_payload();
   48     48   
static TESTPAYLOADBLOBINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    TESTPAYLOADBLOBINPUT_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[&TESTPAYLOADBLOBINPUT_MEMBER_CONTENT_TYPE, &TESTPAYLOADBLOBINPUT_MEMBER_DATA],
   52         -
);
          52  +
)
          53  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/blob_payload", None));
   53     54   
impl TestPayloadBlobInput {
   54     55   
    /// The schema for this shape.
   55     56   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTPAYLOADBLOBINPUT_SCHEMA;
   56     57   
}
   57     58   
impl ::aws_smithy_schema::serde::SerializableStruct for TestPayloadBlobInput {
   58     59   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   59     60   
    fn serialize_members(
   60     61   
        &self,
   61     62   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   62     63   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   63     64   
        if let Some(ref val) = self.content_type {
   64     65   
            ser.write_string(&TESTPAYLOADBLOBINPUT_MEMBER_CONTENT_TYPE, val)?;
   65     66   
        }
   66     67   
        if let Some(ref val) = self.data {
   67     68   
            ser.write_blob(&TESTPAYLOADBLOBINPUT_MEMBER_DATA, val)?;
   68     69   
        }
   69     70   
        Ok(())
   70     71   
    }
   71     72   
}
   72     73   
impl TestPayloadBlobInput {
   73     74   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   74         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   75         -
        deserializer: &mut D,
          75  +
    pub fn deserialize(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   76     77   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   77     78   
        #[allow(unused_variables, unused_mut)]
   78     79   
        let mut builder = Self::builder();
   79     80   
        #[allow(
   80     81   
            unused_variables,
   81     82   
            unreachable_code,
   82     83   
            clippy::single_match,
   83     84   
            clippy::match_single_binding,
   84     85   
            clippy::diverging_sub_expression
   85     86   
        )]
   86         -
        deserializer.read_struct(&TESTPAYLOADBLOBINPUT_SCHEMA, (), |_, member, deser| {
          87  +
        deserializer.read_struct(&TESTPAYLOADBLOBINPUT_SCHEMA, &mut |member, deser| {
   87     88   
            match member.member_index() {
   88     89   
                Some(0) => {
   89     90   
                    builder.content_type = Some(deser.read_string(member)?);
   90     91   
                }
   91     92   
                Some(1) => {
   92     93   
                    builder.data = Some(deser.read_blob(member)?);
   93     94   
                }
   94     95   
                _ => {}
   95     96   
            }
   96     97   
            Ok(())
   97     98   
        })?;
   98     99   
        builder
   99    100   
            .build()
  100    101   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  101    102   
    }
  102    103   
}
         104  +
impl TestPayloadBlobInput {
         105  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         106  +
    /// Header-bound members are read directly from headers, avoiding runtime
         107  +
    /// member iteration overhead. Body members are read via the deserializer.
         108  +
    pub fn deserialize_with_response(
         109  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         110  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         111  +
        _status: u16,
         112  +
        body: &[u8],
         113  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         114  +
        #[allow(unused_variables, unused_mut)]
         115  +
        let mut builder = Self::builder();
         116  +
        if let Some(val) = headers.get("Content-Type") {
         117  +
            builder.content_type = Some(val.to_string());
         118  +
        }
         119  +
        if !body.is_empty() {
         120  +
            builder.data = Some(::aws_smithy_types::Blob::new(body.to_vec()));
         121  +
        }
         122  +
        builder
         123  +
            .build()
         124  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         125  +
    }
         126  +
}
  103    127   
impl TestPayloadBlobInput {
  104    128   
    /// Creates a new builder-style object to manufacture [`TestPayloadBlobInput`](crate::operation::test_payload_blob::TestPayloadBlobInput).
  105    129   
    pub fn builder() -> crate::operation::test_payload_blob::builders::TestPayloadBlobInputBuilder {
  106    130   
        crate::operation::test_payload_blob::builders::TestPayloadBlobInputBuilder::default()
  107    131   
    }
  108    132   
}
  109    133   
  110    134   
/// A builder for [`TestPayloadBlobInput`](crate::operation::test_payload_blob::TestPayloadBlobInput).
  111    135   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  112    136   
#[non_exhaustive]

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

@@ -3,3 +130,151 @@
   23     23   
    "aws.protocoltests.restjson.synthetic",
   24     24   
    "TestPayloadBlobOutput",
   25     25   
);
   26     26   
static TESTPAYLOADBLOBOUTPUT_MEMBER_CONTENT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static(
   28     28   
        "aws.protocoltests.restjson.synthetic#TestPayloadBlobOutput$contentType",
   29     29   
        "aws.protocoltests.restjson.synthetic",
   30     30   
        "TestPayloadBlobOutput",
   31     31   
    ),
   32     32   
    ::aws_smithy_schema::ShapeType::String,
   33         -
    "content_type",
          33  +
    "contentType",
   34     34   
    0,
   35     35   
)
   36     36   
.with_http_header("Content-Type");
   37     37   
static TESTPAYLOADBLOBOUTPUT_MEMBER_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "aws.protocoltests.restjson.synthetic#TestPayloadBlobOutput$data",
   40     40   
        "aws.protocoltests.restjson.synthetic",
   41     41   
        "TestPayloadBlobOutput",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Blob,
   44     44   
    "data",
   45     45   
    1,
   46     46   
)
   47     47   
.with_http_payload();
   48     48   
static TESTPAYLOADBLOBOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    TESTPAYLOADBLOBOUTPUT_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[&TESTPAYLOADBLOBOUTPUT_MEMBER_CONTENT_TYPE, &TESTPAYLOADBLOBOUTPUT_MEMBER_DATA],
   52     52   
);
   53     53   
impl TestPayloadBlobOutput {
   54     54   
    /// The schema for this shape.
   55     55   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTPAYLOADBLOBOUTPUT_SCHEMA;
   56     56   
}
   57     57   
impl ::aws_smithy_schema::serde::SerializableStruct for TestPayloadBlobOutput {
   58     58   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   59     59   
    fn serialize_members(
   60     60   
        &self,
   61     61   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   62     62   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   63     63   
        if let Some(ref val) = self.content_type {
   64     64   
            ser.write_string(&TESTPAYLOADBLOBOUTPUT_MEMBER_CONTENT_TYPE, val)?;
   65     65   
        }
   66     66   
        if let Some(ref val) = self.data {
   67     67   
            ser.write_blob(&TESTPAYLOADBLOBOUTPUT_MEMBER_DATA, val)?;
   68     68   
        }
   69     69   
        Ok(())
   70     70   
    }
   71     71   
}
   72     72   
impl TestPayloadBlobOutput {
   73     73   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   74         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   75         -
        deserializer: &mut D,
          74  +
    pub fn deserialize(
          75  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   76     76   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   77     77   
        #[allow(unused_variables, unused_mut)]
   78     78   
        let mut builder = Self::builder();
   79     79   
        #[allow(
   80     80   
            unused_variables,
   81     81   
            unreachable_code,
   82     82   
            clippy::single_match,
   83     83   
            clippy::match_single_binding,
   84     84   
            clippy::diverging_sub_expression
   85     85   
        )]
   86         -
        deserializer.read_struct(&TESTPAYLOADBLOBOUTPUT_SCHEMA, (), |_, member, deser| {
          86  +
        deserializer.read_struct(&TESTPAYLOADBLOBOUTPUT_SCHEMA, &mut |member, deser| {
   87     87   
            match member.member_index() {
   88     88   
                Some(0) => {
   89     89   
                    builder.content_type = Some(deser.read_string(member)?);
   90     90   
                }
   91     91   
                Some(1) => {
   92     92   
                    builder.data = Some(deser.read_blob(member)?);
   93     93   
                }
   94     94   
                _ => {}
   95     95   
            }
   96     96   
            Ok(())
   97     97   
        })?;
   98     98   
        Ok(builder.build())
   99     99   
    }
  100    100   
}
         101  +
impl TestPayloadBlobOutput {
         102  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         103  +
    /// Header-bound members are read directly from headers, avoiding runtime
         104  +
    /// member iteration overhead. Body members are read via the deserializer.
         105  +
    pub fn deserialize_with_response(
         106  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         107  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         108  +
        _status: u16,
         109  +
        body: &[u8],
         110  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         111  +
        #[allow(unused_variables, unused_mut)]
         112  +
        let mut builder = Self::builder();
         113  +
        if let Some(val) = headers.get("Content-Type") {
         114  +
            builder.content_type = Some(val.to_string());
         115  +
        }
         116  +
        if !body.is_empty() {
         117  +
            builder.data = Some(::aws_smithy_types::Blob::new(body.to_vec()));
         118  +
        }
         119  +
        Ok(builder.build())
         120  +
    }
         121  +
}
  101    122   
impl TestPayloadBlobOutput {
  102    123   
    /// Creates a new builder-style object to manufacture [`TestPayloadBlobOutput`](crate::operation::test_payload_blob::TestPayloadBlobOutput).
  103    124   
    pub fn builder() -> crate::operation::test_payload_blob::builders::TestPayloadBlobOutputBuilder {
  104    125   
        crate::operation::test_payload_blob::builders::TestPayloadBlobOutputBuilder::default()
  105    126   
    }
  106    127   
}
  107    128   
  108    129   
/// A builder for [`TestPayloadBlobOutput`](crate::operation::test_payload_blob::TestPayloadBlobOutput).
  109    130   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  110    131   
#[non_exhaustive]

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

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `TestPayloadStructure`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct TestPayloadStructure;
    6      6   
impl TestPayloadStructure {
    7      7   
    /// Creates a new `TestPayloadStructure`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::test_payload_structure::TestPayloadStructureInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::test_payload_structure::TestPayloadStructureOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::test_payload_structure::TestPayloadStructureInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::test_payload_structure::TestPayloadStructureOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::test_payload_structure::TestPayloadStructureError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -110,114 +235,239 @@
  130    134   
                crate::operation::test_payload_structure::TestPayloadStructureError,
  131    135   
            >::new());
  132    136   
  133    137   
        ::std::borrow::Cow::Owned(rcb)
  134    138   
    }
  135    139   
}
  136    140   
  137    141   
#[derive(Debug)]
  138    142   
struct TestPayloadStructureResponseDeserializer;
  139    143   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for TestPayloadStructureResponseDeserializer {
  140         -
    fn deserialize_nonstreaming(
         144  +
    fn deserialize_nonstreaming_with_config(
  141    145   
        &self,
  142    146   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         147  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  143    148   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  144    149   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
         150  +
        #[allow(unused_mut)]
         151  +
        let mut force_error = false;
         152  +
         153  +
        if !success && status != 200 || force_error {
  145    154   
            let headers = response.headers();
  146    155   
            let body = response.body().bytes().expect("body loaded");
  147    156   
            #[allow(unused_mut)]
  148         -
        let mut force_error = false;
         157  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         158  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         159  +
            })?;
  149    160   
  150         -
        let parse_result = if !success && status != 200 || force_error {
  151         -
            crate::protocol_serde::shape_test_payload_structure::de_test_payload_structure_http_error(status, headers, body)
         161  +
            let generic = generic_builder.build();
         162  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         163  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
         164  +
                    crate::operation::test_payload_structure::TestPayloadStructureError::generic(generic),
         165  +
                ),
         166  +
            ))
  152    167   
        } else {
  153         -
            crate::protocol_serde::shape_test_payload_structure::de_test_payload_structure_http_response(status, headers, body)
  154         -
        };
  155         -
        crate::protocol_serde::type_erase_result(parse_result)
         168  +
            let protocol = _cfg
         169  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         170  +
                .expect("a SharedClientProtocol is required");
         171  +
            let mut deser = protocol
         172  +
                .deserialize_response(response, TestPayloadStructure::OUTPUT_SCHEMA, _cfg)
         173  +
                .map_err(|e| {
         174  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         175  +
                })?;
         176  +
            let body = response.body().bytes().expect("body loaded");
         177  +
            let output = crate::operation::test_payload_structure::TestPayloadStructureOutput::deserialize_with_response(
         178  +
                &mut *deser,
         179  +
                response.headers(),
         180  +
                response.status().into(),
         181  +
                body,
         182  +
            )
         183  +
            .map_err(|e| {
         184  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         185  +
            })?;
         186  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         187  +
        }
  156    188   
    }
  157    189   
}
  158    190   
#[derive(Debug)]
  159    191   
struct TestPayloadStructureRequestSerializer;
  160    192   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for TestPayloadStructureRequestSerializer {
  161    193   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  162    194   
    fn serialize_input(
  163    195   
        &self,
  164    196   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  165    197   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  166    198   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  167    199   
        let input = input
  168    200   
            .downcast::<crate::operation::test_payload_structure::TestPayloadStructureInput>()
  169    201   
            .expect("correct type");
  170         -
        let _header_serialization_settings = _cfg
  171         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  172         -
            .cloned()
  173         -
            .unwrap_or_default();
  174         -
        let mut request_builder = {
  175         -
            #[allow(clippy::uninlined_format_args)]
  176         -
            fn uri_base(
  177         -
                _input: &crate::operation::test_payload_structure::TestPayloadStructureInput,
  178         -
                output: &mut ::std::string::String,
  179         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  180         -
                use ::std::fmt::Write as _;
  181         -
                ::std::write!(output, "/payload").expect("formatting should succeed");
  182         -
                ::std::result::Result::Ok(())
  183         -
            }
  184         -
            #[allow(clippy::unnecessary_wraps)]
  185         -
            fn update_http_builder(
  186         -
                input: &crate::operation::test_payload_structure::TestPayloadStructureInput,
  187         -
                builder: ::http_1x::request::Builder,
  188         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  189         -
                let mut uri = ::std::string::String::new();
  190         -
                uri_base(input, &mut uri)?;
  191         -
                let builder = crate::protocol_serde::shape_test_payload_structure::ser_test_payload_structure_headers(input, builder)?;
  192         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  193         -
            }
  194         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  195         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  196         -
            builder
  197         -
        };
  198         -
        let body = ::aws_smithy_types::body::SdkBody::from(
  199         -
            crate::protocol_serde::shape_test_payload_structure_input::ser_payload_config_http_payload(&input.payload_config)?,
  200         -
        );
  201         -
        if let Some(content_length) = body.content_length() {
  202         -
            let content_length = content_length.to_string();
  203         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  204         -
        }
  205         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         202  +
        let protocol = _cfg
         203  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         204  +
            .expect("a SharedClientProtocol is required");
         205  +
        let mut request = protocol
         206  +
            .serialize_request(&input, TestPayloadStructure::INPUT_SCHEMA, "", _cfg)
         207  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         208  +
         209  +
        return ::std::result::Result::Ok(request);
  206    210   
    }
  207    211   
}
  208    212   
#[derive(Debug)]
  209    213   
struct TestPayloadStructureEndpointParamsInterceptor;
  210    214   
  211    215   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TestPayloadStructureEndpointParamsInterceptor {
  212    216   
    fn name(&self) -> &'static str {
  213    217   
        "TestPayloadStructureEndpointParamsInterceptor"
  214    218   
    }
  215    219

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

@@ -3,3 +135,159 @@
   23     23   
    "aws.protocoltests.restjson.synthetic",
   24     24   
    "TestPayloadStructureInput",
   25     25   
);
   26     26   
static TESTPAYLOADSTRUCTUREINPUT_MEMBER_TEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static(
   28     28   
        "aws.protocoltests.restjson.synthetic#TestPayloadStructureInput$testId",
   29     29   
        "aws.protocoltests.restjson.synthetic",
   30     30   
        "TestPayloadStructureInput",
   31     31   
    ),
   32     32   
    ::aws_smithy_schema::ShapeType::String,
   33         -
    "test_id",
          33  +
    "testId",
   34     34   
    0,
   35     35   
)
   36     36   
.with_http_header("x-amz-test-id");
   37     37   
static TESTPAYLOADSTRUCTUREINPUT_MEMBER_PAYLOAD_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "aws.protocoltests.restjson.synthetic#TestPayloadStructureInput$payloadConfig",
   40     40   
        "aws.protocoltests.restjson.synthetic",
   41     41   
        "TestPayloadStructureInput",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Structure,
   44         -
    "payload_config",
          44  +
    "payloadConfig",
   45     45   
    1,
   46     46   
)
   47     47   
.with_http_payload();
   48     48   
static TESTPAYLOADSTRUCTUREINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    TESTPAYLOADSTRUCTUREINPUT_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[
   52     52   
        &TESTPAYLOADSTRUCTUREINPUT_MEMBER_TEST_ID,
   53     53   
        &TESTPAYLOADSTRUCTUREINPUT_MEMBER_PAYLOAD_CONFIG,
   54     54   
    ],
   55         -
);
          55  +
)
          56  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/payload", None));
   56     57   
impl TestPayloadStructureInput {
   57     58   
    /// The schema for this shape.
   58     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTPAYLOADSTRUCTUREINPUT_SCHEMA;
   59     60   
}
   60     61   
impl ::aws_smithy_schema::serde::SerializableStruct for TestPayloadStructureInput {
   61     62   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   62     63   
    fn serialize_members(
   63     64   
        &self,
   64     65   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   65     66   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   66     67   
        if let Some(ref val) = self.test_id {
   67     68   
            ser.write_string(&TESTPAYLOADSTRUCTUREINPUT_MEMBER_TEST_ID, val)?;
   68     69   
        }
   69     70   
        if let Some(ref val) = self.payload_config {
   70     71   
            ser.write_struct(&TESTPAYLOADSTRUCTUREINPUT_MEMBER_PAYLOAD_CONFIG, val)?;
   71     72   
        }
   72     73   
        Ok(())
   73     74   
    }
   74     75   
}
   75     76   
impl TestPayloadStructureInput {
   76     77   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   77         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   78         -
        deserializer: &mut D,
          78  +
    pub fn deserialize(
          79  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   79     80   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   80     81   
        #[allow(unused_variables, unused_mut)]
   81     82   
        let mut builder = Self::builder();
   82     83   
        #[allow(
   83     84   
            unused_variables,
   84     85   
            unreachable_code,
   85     86   
            clippy::single_match,
   86     87   
            clippy::match_single_binding,
   87     88   
            clippy::diverging_sub_expression
   88     89   
        )]
   89         -
        deserializer.read_struct(&TESTPAYLOADSTRUCTUREINPUT_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&TESTPAYLOADSTRUCTUREINPUT_SCHEMA, &mut |member, deser| {
   90     91   
            match member.member_index() {
   91     92   
                Some(0) => {
   92     93   
                    builder.test_id = Some(deser.read_string(member)?);
   93     94   
                }
   94     95   
                Some(1) => {
   95     96   
                    builder.payload_config = Some(crate::types::PayloadConfig::deserialize(deser)?);
   96     97   
                }
   97     98   
                _ => {}
   98     99   
            }
   99    100   
            Ok(())
  100    101   
        })?;
  101    102   
        builder
  102    103   
            .build()
  103    104   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  104    105   
    }
  105    106   
}
         107  +
impl TestPayloadStructureInput {
         108  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         109  +
    /// Header-bound members are read directly from headers, avoiding runtime
         110  +
    /// member iteration overhead. Body members are read via the deserializer.
         111  +
    pub fn deserialize_with_response(
         112  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         113  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         114  +
        _status: u16,
         115  +
        body: &[u8],
         116  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         117  +
        #[allow(unused_variables, unused_mut)]
         118  +
        let mut builder = Self::builder();
         119  +
        if let Some(val) = headers.get("x-amz-test-id") {
         120  +
            builder.test_id = Some(val.to_string());
         121  +
        }
         122  +
        if !body.is_empty() {
         123  +
            builder.payload_config = Some(crate::types::PayloadConfig::deserialize(deserializer)?);
         124  +
        }
         125  +
        builder
         126  +
            .build()
         127  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         128  +
    }
         129  +
}
  106    130   
impl TestPayloadStructureInput {
  107    131   
    /// Creates a new builder-style object to manufacture [`TestPayloadStructureInput`](crate::operation::test_payload_structure::TestPayloadStructureInput).
  108    132   
    pub fn builder() -> crate::operation::test_payload_structure::builders::TestPayloadStructureInputBuilder {
  109    133   
        crate::operation::test_payload_structure::builders::TestPayloadStructureInputBuilder::default()
  110    134   
    }
  111    135   
}
  112    136   
  113    137   
/// A builder for [`TestPayloadStructureInput`](crate::operation::test_payload_structure::TestPayloadStructureInput).
  114    138   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  115    139   
#[non_exhaustive]

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

@@ -3,3 +133,154 @@
   23     23   
    "aws.protocoltests.restjson.synthetic",
   24     24   
    "TestPayloadStructureOutput",
   25     25   
);
   26     26   
static TESTPAYLOADSTRUCTUREOUTPUT_MEMBER_TEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static(
   28     28   
        "aws.protocoltests.restjson.synthetic#TestPayloadStructureOutput$testId",
   29     29   
        "aws.protocoltests.restjson.synthetic",
   30     30   
        "TestPayloadStructureOutput",
   31     31   
    ),
   32     32   
    ::aws_smithy_schema::ShapeType::String,
   33         -
    "test_id",
          33  +
    "testId",
   34     34   
    0,
   35     35   
)
   36     36   
.with_http_header("x-amz-test-id");
   37     37   
static TESTPAYLOADSTRUCTUREOUTPUT_MEMBER_PAYLOAD_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "aws.protocoltests.restjson.synthetic#TestPayloadStructureOutput$payloadConfig",
   40     40   
        "aws.protocoltests.restjson.synthetic",
   41     41   
        "TestPayloadStructureOutput",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Structure,
   44         -
    "payload_config",
          44  +
    "payloadConfig",
   45     45   
    1,
   46     46   
)
   47     47   
.with_http_payload();
   48     48   
static TESTPAYLOADSTRUCTUREOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    TESTPAYLOADSTRUCTUREOUTPUT_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[
   52     52   
        &TESTPAYLOADSTRUCTUREOUTPUT_MEMBER_TEST_ID,
   53     53   
        &TESTPAYLOADSTRUCTUREOUTPUT_MEMBER_PAYLOAD_CONFIG,
   54     54   
    ],
   55     55   
);
   56     56   
impl TestPayloadStructureOutput {
   57     57   
    /// The schema for this shape.
   58     58   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTPAYLOADSTRUCTUREOUTPUT_SCHEMA;
   59     59   
}
   60     60   
impl ::aws_smithy_schema::serde::SerializableStruct for TestPayloadStructureOutput {
   61     61   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   62     62   
    fn serialize_members(
   63     63   
        &self,
   64     64   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   65     65   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   66     66   
        if let Some(ref val) = self.test_id {
   67     67   
            ser.write_string(&TESTPAYLOADSTRUCTUREOUTPUT_MEMBER_TEST_ID, val)?;
   68     68   
        }
   69     69   
        if let Some(ref val) = self.payload_config {
   70     70   
            ser.write_struct(&TESTPAYLOADSTRUCTUREOUTPUT_MEMBER_PAYLOAD_CONFIG, val)?;
   71     71   
        }
   72     72   
        Ok(())
   73     73   
    }
   74     74   
}
   75     75   
impl TestPayloadStructureOutput {
   76     76   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   77         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   78         -
        deserializer: &mut D,
          77  +
    pub fn deserialize(
          78  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   79     79   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   80     80   
        #[allow(unused_variables, unused_mut)]
   81     81   
        let mut builder = Self::builder();
   82     82   
        #[allow(
   83     83   
            unused_variables,
   84     84   
            unreachable_code,
   85     85   
            clippy::single_match,
   86     86   
            clippy::match_single_binding,
   87     87   
            clippy::diverging_sub_expression
   88     88   
        )]
   89         -
        deserializer.read_struct(&TESTPAYLOADSTRUCTUREOUTPUT_SCHEMA, (), |_, member, deser| {
          89  +
        deserializer.read_struct(&TESTPAYLOADSTRUCTUREOUTPUT_SCHEMA, &mut |member, deser| {
   90     90   
            match member.member_index() {
   91     91   
                Some(0) => {
   92     92   
                    builder.test_id = Some(deser.read_string(member)?);
   93     93   
                }
   94     94   
                Some(1) => {
   95     95   
                    builder.payload_config = Some(crate::types::PayloadConfig::deserialize(deser)?);
   96     96   
                }
   97     97   
                _ => {}
   98     98   
            }
   99     99   
            Ok(())
  100    100   
        })?;
  101    101   
        Ok(builder.build())
  102    102   
    }
  103    103   
}
         104  +
impl TestPayloadStructureOutput {
         105  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         106  +
    /// Header-bound members are read directly from headers, avoiding runtime
         107  +
    /// member iteration overhead. Body members are read via the deserializer.
         108  +
    pub fn deserialize_with_response(
         109  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         110  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         111  +
        _status: u16,
         112  +
        body: &[u8],
         113  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         114  +
        #[allow(unused_variables, unused_mut)]
         115  +
        let mut builder = Self::builder();
         116  +
        if let Some(val) = headers.get("x-amz-test-id") {
         117  +
            builder.test_id = Some(val.to_string());
         118  +
        }
         119  +
        if !body.is_empty() {
         120  +
            builder.payload_config = Some(crate::types::PayloadConfig::deserialize(deserializer)?);
         121  +
        }
         122  +
        Ok(builder.build())
         123  +
    }
         124  +
}
  104    125   
impl TestPayloadStructureOutput {
  105    126   
    /// Creates a new builder-style object to manufacture [`TestPayloadStructureOutput`](crate::operation::test_payload_structure::TestPayloadStructureOutput).
  106    127   
    pub fn builder() -> crate::operation::test_payload_structure::builders::TestPayloadStructureOutputBuilder {
  107    128   
        crate::operation::test_payload_structure::builders::TestPayloadStructureOutputBuilder::default()
  108    129   
    }
  109    130   
}
  110    131   
  111    132   
/// A builder for [`TestPayloadStructureOutput`](crate::operation::test_payload_structure::TestPayloadStructureOutput).
  112    133   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  113    134   
#[non_exhaustive]

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

@@ -1,1 +40,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `TestPostNoInputNoPayload`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct TestPostNoInputNoPayload;
    6      6   
impl TestPostNoInputNoPayload {
    7      7   
    /// Creates a new `TestPostNoInputNoPayload`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -110,116 +228,241 @@
  130    136   
                crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadError,
  131    137   
            >::new());
  132    138   
  133    139   
        ::std::borrow::Cow::Owned(rcb)
  134    140   
    }
  135    141   
}
  136    142   
  137    143   
#[derive(Debug)]
  138    144   
struct TestPostNoInputNoPayloadResponseDeserializer;
  139    145   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for TestPostNoInputNoPayloadResponseDeserializer {
  140         -
    fn deserialize_nonstreaming(
         146  +
    fn deserialize_nonstreaming_with_config(
  141    147   
        &self,
  142    148   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         149  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  143    150   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  144    151   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
         152  +
        #[allow(unused_mut)]
         153  +
        let mut force_error = false;
         154  +
         155  +
        if !success && status != 200 || force_error {
  145    156   
            let headers = response.headers();
  146    157   
            let body = response.body().bytes().expect("body loaded");
  147    158   
            #[allow(unused_mut)]
  148         -
        let mut force_error = false;
         159  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         160  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         161  +
            })?;
  149    162   
  150         -
        let parse_result = if !success && status != 200 || force_error {
  151         -
            crate::protocol_serde::shape_test_post_no_input_no_payload::de_test_post_no_input_no_payload_http_error(status, headers, body)
         163  +
            let generic = generic_builder.build();
         164  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         165  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
         166  +
                    crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadError::generic(generic),
         167  +
                ),
         168  +
            ))
  152    169   
        } else {
  153         -
            crate::protocol_serde::shape_test_post_no_input_no_payload::de_test_post_no_input_no_payload_http_response(status, headers, body)
  154         -
        };
  155         -
        crate::protocol_serde::type_erase_result(parse_result)
         170  +
            let protocol = _cfg
         171  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         172  +
                .expect("a SharedClientProtocol is required");
         173  +
            let mut deser = protocol
         174  +
                .deserialize_response(response, TestPostNoInputNoPayload::OUTPUT_SCHEMA, _cfg)
         175  +
                .map_err(|e| {
         176  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         177  +
                })?;
         178  +
            let body = response.body().bytes().expect("body loaded");
         179  +
            let output = crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadOutput::deserialize_with_response(
         180  +
                &mut *deser,
         181  +
                response.headers(),
         182  +
                response.status().into(),
         183  +
                body,
         184  +
            )
         185  +
            .map_err(|e| {
         186  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         187  +
            })?;
         188  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         189  +
        }
  156    190   
    }
  157    191   
}
  158    192   
#[derive(Debug)]
  159    193   
struct TestPostNoInputNoPayloadRequestSerializer;
  160    194   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for TestPostNoInputNoPayloadRequestSerializer {
  161    195   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  162    196   
    fn serialize_input(
  163    197   
        &self,
  164    198   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  165    199   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  166    200   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  167    201   
        let input = input
  168    202   
            .downcast::<crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadInput>()
  169    203   
            .expect("correct type");
  170         -
        let _header_serialization_settings = _cfg
  171         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  172         -
            .cloned()
  173         -
            .unwrap_or_default();
  174         -
        let mut request_builder = {
  175         -
            #[allow(clippy::uninlined_format_args)]
  176         -
            fn uri_base(
  177         -
                _input: &crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadInput,
  178         -
                output: &mut ::std::string::String,
  179         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  180         -
                use ::std::fmt::Write as _;
  181         -
                ::std::write!(output, "/no_input_no_payload").expect("formatting should succeed");
  182         -
                ::std::result::Result::Ok(())
  183         -
            }
  184         -
            #[allow(clippy::unnecessary_wraps)]
  185         -
            fn update_http_builder(
  186         -
                input: &crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadInput,
  187         -
                builder: ::http_1x::request::Builder,
  188         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  189         -
                let mut uri = ::std::string::String::new();
  190         -
                uri_base(input, &mut uri)?;
  191         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  192         -
            }
  193         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  194         -
            builder
  195         -
        };
  196         -
        let body = ::aws_smithy_types::body::SdkBody::from("");
         204  +
        let protocol = _cfg
         205  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         206  +
            .expect("a SharedClientProtocol is required");
         207  +
        let mut request = protocol
         208  +
            .serialize_request(&input, TestPostNoInputNoPayload::INPUT_SCHEMA, "", _cfg)
         209  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
  197    210   
  198         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         211  +
        return ::std::result::Result::Ok(request);
  199    212   
    }
  200    213   
}
  201    214   
#[derive(Debug)]
  202    215   
struct TestPostNoInputNoPayloadEndpointParamsInterceptor;
  203    216   
  204    217   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TestPostNoInputNoPayloadEndpointParamsInterceptor {
  205    218   
    fn name(&self) -> &'static str {
  206    219   
        "TestPostNoInputNoPayloadEndpointParamsInterceptor"
  207    220   
    }
  208    221

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

@@ -1,1 +72,86 @@
    2      2   
#[allow(missing_docs)] // documentation missing in model
    3      3   
#[non_exhaustive]
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5      5   
pub struct TestPostNoInputNoPayloadInput {}
    6      6   
static TESTPOSTNOINPUTNOPAYLOADINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
    7      7   
    "aws.protocoltests.restjson.synthetic#TestPostNoInputNoPayloadInput",
    8      8   
    "aws.protocoltests.restjson.synthetic",
    9      9   
    "TestPostNoInputNoPayloadInput",
   10     10   
);
   11     11   
static TESTPOSTNOINPUTNOPAYLOADINPUT_SCHEMA: ::aws_smithy_schema::Schema =
   12         -
    ::aws_smithy_schema::Schema::new_struct(TESTPOSTNOINPUTNOPAYLOADINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
          12  +
    ::aws_smithy_schema::Schema::new_struct(TESTPOSTNOINPUTNOPAYLOADINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[])
          13  +
        .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/no_input_no_payload", None));
   13     14   
impl TestPostNoInputNoPayloadInput {
   14     15   
    /// The schema for this shape.
   15     16   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTPOSTNOINPUTNOPAYLOADINPUT_SCHEMA;
   16     17   
}
   17     18   
impl ::aws_smithy_schema::serde::SerializableStruct for TestPostNoInputNoPayloadInput {
   18     19   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   19     20   
    fn serialize_members(
   20     21   
        &self,
   21     22   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   22     23   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   23     24   
        Ok(())
   24     25   
    }
   25     26   
}
   26     27   
impl TestPostNoInputNoPayloadInput {
   27     28   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   28         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   29         -
        deserializer: &mut D,
          29  +
    pub fn deserialize(
          30  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   30     31   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   31     32   
        #[allow(unused_variables, unused_mut)]
   32     33   
        let mut builder = Self::builder();
   33     34   
        #[allow(
   34     35   
            unused_variables,
   35     36   
            unreachable_code,
   36     37   
            clippy::single_match,
   37     38   
            clippy::match_single_binding,
   38     39   
            clippy::diverging_sub_expression
   39     40   
        )]
   40         -
        deserializer.read_struct(&TESTPOSTNOINPUTNOPAYLOADINPUT_SCHEMA, (), |_, member, deser| {
          41  +
        deserializer.read_struct(&TESTPOSTNOINPUTNOPAYLOADINPUT_SCHEMA, &mut |member, deser| {
   41     42   
            match member.member_index() {
   42     43   
                _ => {}
   43     44   
            }
   44     45   
            Ok(())
   45     46   
        })?;
   46     47   
        builder
   47     48   
            .build()
   48     49   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   49     50   
    }
   50     51   
}
          52  +
impl TestPostNoInputNoPayloadInput {
          53  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          54  +
    pub fn deserialize_with_response(
          55  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          56  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          57  +
        _status: u16,
          58  +
        _body: &[u8],
          59  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          60  +
        Self::builder()
          61  +
            .build()
          62  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
          63  +
    }
          64  +
}
   51     65   
impl TestPostNoInputNoPayloadInput {
   52     66   
    /// Creates a new builder-style object to manufacture [`TestPostNoInputNoPayloadInput`](crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadInput).
   53     67   
    pub fn builder() -> crate::operation::test_post_no_input_no_payload::builders::TestPostNoInputNoPayloadInputBuilder {
   54     68   
        crate::operation::test_post_no_input_no_payload::builders::TestPostNoInputNoPayloadInputBuilder::default()
   55     69   
    }
   56     70   
}
   57     71   
   58     72   
/// A builder for [`TestPostNoInputNoPayloadInput`](crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadInput).
   59     73   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   60     74   
#[non_exhaustive]

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

@@ -1,1 +107,125 @@
   17     17   
    "aws.protocoltests.restjson.synthetic",
   18     18   
    "TestPostNoInputNoPayloadOutput",
   19     19   
);
   20     20   
static TESTPOSTNOINPUTNOPAYLOADOUTPUT_MEMBER_TEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   21     21   
    ::aws_smithy_schema::ShapeId::from_static(
   22     22   
        "aws.protocoltests.restjson.synthetic#TestPostNoInputNoPayloadOutput$testId",
   23     23   
        "aws.protocoltests.restjson.synthetic",
   24     24   
        "TestPostNoInputNoPayloadOutput",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "test_id",
          27  +
    "testId",
   28     28   
    0,
   29     29   
)
   30     30   
.with_http_header("X-Amz-Test-Id");
   31     31   
static TESTPOSTNOINPUTNOPAYLOADOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    TESTPOSTNOINPUTNOPAYLOADOUTPUT_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&TESTPOSTNOINPUTNOPAYLOADOUTPUT_MEMBER_TEST_ID],
   35     35   
);
   36     36   
impl TestPostNoInputNoPayloadOutput {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTPOSTNOINPUTNOPAYLOADOUTPUT_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for TestPostNoInputNoPayloadOutput {
   41     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     42   
    fn serialize_members(
   43     43   
        &self,
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        if let Some(ref val) = self.test_id {
   47     47   
            ser.write_string(&TESTPOSTNOINPUTNOPAYLOADOUTPUT_MEMBER_TEST_ID, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl TestPostNoInputNoPayloadOutput {
   53     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     57   
        #[allow(unused_variables, unused_mut)]
   58     58   
        let mut builder = Self::builder();
   59     59   
        #[allow(
   60     60   
            unused_variables,
   61     61   
            unreachable_code,
   62     62   
            clippy::single_match,
   63     63   
            clippy::match_single_binding,
   64     64   
            clippy::diverging_sub_expression
   65     65   
        )]
   66         -
        deserializer.read_struct(&TESTPOSTNOINPUTNOPAYLOADOUTPUT_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&TESTPOSTNOINPUTNOPAYLOADOUTPUT_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.test_id = Some(deser.read_string(member)?);
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl TestPostNoInputNoPayloadOutput {
          79  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          80  +
    /// Header-bound members are read directly from headers, avoiding runtime
          81  +
    /// member iteration overhead. Body members are read via the deserializer.
          82  +
    pub fn deserialize_with_response(
          83  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          84  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          85  +
        _status: u16,
          86  +
        _body: &[u8],
          87  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          88  +
        #[allow(unused_variables, unused_mut)]
          89  +
        let mut builder = Self::builder();
          90  +
        if let Some(val) = headers.get("X-Amz-Test-Id") {
          91  +
            builder.test_id = Some(val.to_string());
          92  +
        }
          93  +
        Ok(builder.build())
          94  +
    }
          95  +
}
   78     96   
impl TestPostNoInputNoPayloadOutput {
   79     97   
    /// Creates a new builder-style object to manufacture [`TestPostNoInputNoPayloadOutput`](crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadOutput).
   80     98   
    pub fn builder() -> crate::operation::test_post_no_input_no_payload::builders::TestPostNoInputNoPayloadOutputBuilder {
   81     99   
        crate::operation::test_post_no_input_no_payload::builders::TestPostNoInputNoPayloadOutputBuilder::default()
   82    100   
    }
   83    101   
}
   84    102   
   85    103   
/// A builder for [`TestPostNoInputNoPayloadOutput`](crate::operation::test_post_no_input_no_payload::TestPostNoInputNoPayloadOutput).
   86    104   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   87    105   
#[non_exhaustive]

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

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `TestPostNoPayload`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct TestPostNoPayload;
    6      6   
impl TestPostNoPayload {
    7      7   
    /// Creates a new `TestPostNoPayload`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::test_post_no_payload::TestPostNoPayloadInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::test_post_no_payload::TestPostNoPayloadOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::test_post_no_payload::TestPostNoPayloadInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::test_post_no_payload::TestPostNoPayloadOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::test_post_no_payload::TestPostNoPayloadError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -110,114 +229,239 @@
  130    134   
                crate::operation::test_post_no_payload::TestPostNoPayloadError,
  131    135   
            >::new());
  132    136   
  133    137   
        ::std::borrow::Cow::Owned(rcb)
  134    138   
    }
  135    139   
}
  136    140   
  137    141   
#[derive(Debug)]
  138    142   
struct TestPostNoPayloadResponseDeserializer;
  139    143   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for TestPostNoPayloadResponseDeserializer {
  140         -
    fn deserialize_nonstreaming(
         144  +
    fn deserialize_nonstreaming_with_config(
  141    145   
        &self,
  142    146   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         147  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  143    148   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  144    149   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
         150  +
        #[allow(unused_mut)]
         151  +
        let mut force_error = false;
         152  +
         153  +
        if !success && status != 200 || force_error {
  145    154   
            let headers = response.headers();
  146    155   
            let body = response.body().bytes().expect("body loaded");
  147    156   
            #[allow(unused_mut)]
  148         -
        let mut force_error = false;
         157  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         158  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         159  +
            })?;
  149    160   
  150         -
        let parse_result = if !success && status != 200 || force_error {
  151         -
            crate::protocol_serde::shape_test_post_no_payload::de_test_post_no_payload_http_error(status, headers, body)
         161  +
            let generic = generic_builder.build();
         162  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         163  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
         164  +
                    crate::operation::test_post_no_payload::TestPostNoPayloadError::generic(generic),
         165  +
                ),
         166  +
            ))
  152    167   
        } else {
  153         -
            crate::protocol_serde::shape_test_post_no_payload::de_test_post_no_payload_http_response(status, headers, body)
  154         -
        };
  155         -
        crate::protocol_serde::type_erase_result(parse_result)
         168  +
            let protocol = _cfg
         169  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         170  +
                .expect("a SharedClientProtocol is required");
         171  +
            let mut deser = protocol
         172  +
                .deserialize_response(response, TestPostNoPayload::OUTPUT_SCHEMA, _cfg)
         173  +
                .map_err(|e| {
         174  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         175  +
                })?;
         176  +
            let body = response.body().bytes().expect("body loaded");
         177  +
            let output = crate::operation::test_post_no_payload::TestPostNoPayloadOutput::deserialize_with_response(
         178  +
                &mut *deser,
         179  +
                response.headers(),
         180  +
                response.status().into(),
         181  +
                body,
         182  +
            )
         183  +
            .map_err(|e| {
         184  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         185  +
            })?;
         186  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         187  +
        }
  156    188   
    }
  157    189   
}
  158    190   
#[derive(Debug)]
  159    191   
struct TestPostNoPayloadRequestSerializer;
  160    192   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for TestPostNoPayloadRequestSerializer {
  161    193   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  162    194   
    fn serialize_input(
  163    195   
        &self,
  164    196   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  165    197   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  166    198   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  167    199   
        let input = input
  168    200   
            .downcast::<crate::operation::test_post_no_payload::TestPostNoPayloadInput>()
  169    201   
            .expect("correct type");
  170         -
        let _header_serialization_settings = _cfg
  171         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  172         -
            .cloned()
  173         -
            .unwrap_or_default();
  174         -
        let mut request_builder = {
  175         -
            #[allow(clippy::uninlined_format_args)]
  176         -
            fn uri_base(
  177         -
                _input: &crate::operation::test_post_no_payload::TestPostNoPayloadInput,
  178         -
                output: &mut ::std::string::String,
  179         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  180         -
                use ::std::fmt::Write as _;
  181         -
                ::std::write!(output, "/no_payload").expect("formatting should succeed");
  182         -
                ::std::result::Result::Ok(())
  183         -
            }
  184         -
            #[allow(clippy::unnecessary_wraps)]
  185         -
            fn update_http_builder(
  186         -
                input: &crate::operation::test_post_no_payload::TestPostNoPayloadInput,
  187         -
                builder: ::http_1x::request::Builder,
  188         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  189         -
                let mut uri = ::std::string::String::new();
  190         -
                uri_base(input, &mut uri)?;
  191         -
                let builder = crate::protocol_serde::shape_test_post_no_payload::ser_test_post_no_payload_headers(input, builder)?;
  192         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  193         -
            }
  194         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  195         -
            builder
  196         -
        };
  197         -
        let body = ::aws_smithy_types::body::SdkBody::from("");
         202  +
        let protocol = _cfg
         203  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         204  +
            .expect("a SharedClientProtocol is required");
         205  +
        let mut request = protocol
         206  +
            .serialize_request(&input, TestPostNoPayload::INPUT_SCHEMA, "", _cfg)
         207  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
  198    208   
  199         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         209  +
        return ::std::result::Result::Ok(request);
  200    210   
    }
  201    211   
}
  202    212   
#[derive(Debug)]
  203    213   
struct TestPostNoPayloadEndpointParamsInterceptor;
  204    214   
  205    215   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TestPostNoPayloadEndpointParamsInterceptor {
  206    216   
    fn name(&self) -> &'static str {
  207    217   
        "TestPostNoPayloadEndpointParamsInterceptor"
  208    218   
    }
  209    219

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

@@ -1,1 +109,130 @@
   17     17   
    "aws.protocoltests.restjson.synthetic",
   18     18   
    "TestPostNoPayloadInput",
   19     19   
);
   20     20   
static TESTPOSTNOPAYLOADINPUT_MEMBER_TEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   21     21   
    ::aws_smithy_schema::ShapeId::from_static(
   22     22   
        "aws.protocoltests.restjson.synthetic#TestPostNoPayloadInput$testId",
   23     23   
        "aws.protocoltests.restjson.synthetic",
   24     24   
        "TestPostNoPayloadInput",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "test_id",
          27  +
    "testId",
   28     28   
    0,
   29     29   
)
   30     30   
.with_http_header("X-Amz-Test-Id");
   31     31   
static TESTPOSTNOPAYLOADINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    TESTPOSTNOPAYLOADINPUT_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&TESTPOSTNOPAYLOADINPUT_MEMBER_TEST_ID],
   35         -
);
          35  +
)
          36  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/no_payload", None));
   36     37   
impl TestPostNoPayloadInput {
   37     38   
    /// The schema for this shape.
   38     39   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTPOSTNOPAYLOADINPUT_SCHEMA;
   39     40   
}
   40     41   
impl ::aws_smithy_schema::serde::SerializableStruct for TestPostNoPayloadInput {
   41     42   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     43   
    fn serialize_members(
   43     44   
        &self,
   44     45   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     46   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     47   
        if let Some(ref val) = self.test_id {
   47     48   
            ser.write_string(&TESTPOSTNOPAYLOADINPUT_MEMBER_TEST_ID, val)?;
   48     49   
        }
   49     50   
        Ok(())
   50     51   
    }
   51     52   
}
   52     53   
impl TestPostNoPayloadInput {
   53     54   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          55  +
    pub fn deserialize(
          56  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     57   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     58   
        #[allow(unused_variables, unused_mut)]
   58     59   
        let mut builder = Self::builder();
   59     60   
        #[allow(
   60     61   
            unused_variables,
   61     62   
            unreachable_code,
   62     63   
            clippy::single_match,
   63     64   
            clippy::match_single_binding,
   64     65   
            clippy::diverging_sub_expression
   65     66   
        )]
   66         -
        deserializer.read_struct(&TESTPOSTNOPAYLOADINPUT_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&TESTPOSTNOPAYLOADINPUT_SCHEMA, &mut |member, deser| {
   67     68   
            match member.member_index() {
   68     69   
                Some(0) => {
   69     70   
                    builder.test_id = Some(deser.read_string(member)?);
   70     71   
                }
   71     72   
                _ => {}
   72     73   
            }
   73     74   
            Ok(())
   74     75   
        })?;
   75     76   
        builder
   76     77   
            .build()
   77     78   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   78     79   
    }
   79     80   
}
          81  +
impl TestPostNoPayloadInput {
          82  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          83  +
    /// Header-bound members are read directly from headers, avoiding runtime
          84  +
    /// member iteration overhead. Body members are read via the deserializer.
          85  +
    pub fn deserialize_with_response(
          86  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          87  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          88  +
        _status: u16,
          89  +
        _body: &[u8],
          90  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          91  +
        #[allow(unused_variables, unused_mut)]
          92  +
        let mut builder = Self::builder();
          93  +
        if let Some(val) = headers.get("X-Amz-Test-Id") {
          94  +
            builder.test_id = Some(val.to_string());
          95  +
        }
          96  +
        builder
          97  +
            .build()
          98  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
          99  +
    }
         100  +
}
   80    101   
impl TestPostNoPayloadInput {
   81    102   
    /// Creates a new builder-style object to manufacture [`TestPostNoPayloadInput`](crate::operation::test_post_no_payload::TestPostNoPayloadInput).
   82    103   
    pub fn builder() -> crate::operation::test_post_no_payload::builders::TestPostNoPayloadInputBuilder {
   83    104   
        crate::operation::test_post_no_payload::builders::TestPostNoPayloadInputBuilder::default()
   84    105   
    }
   85    106   
}
   86    107   
   87    108   
/// A builder for [`TestPostNoPayloadInput`](crate::operation::test_post_no_payload::TestPostNoPayloadInput).
   88    109   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   89    110   
#[non_exhaustive]

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

@@ -1,1 +107,125 @@
   17     17   
    "aws.protocoltests.restjson.synthetic",
   18     18   
    "TestPostNoPayloadOutput",
   19     19   
);
   20     20   
static TESTPOSTNOPAYLOADOUTPUT_MEMBER_TEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   21     21   
    ::aws_smithy_schema::ShapeId::from_static(
   22     22   
        "aws.protocoltests.restjson.synthetic#TestPostNoPayloadOutput$testId",
   23     23   
        "aws.protocoltests.restjson.synthetic",
   24     24   
        "TestPostNoPayloadOutput",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "test_id",
          27  +
    "testId",
   28     28   
    0,
   29     29   
)
   30     30   
.with_http_header("X-Amz-Test-Id");
   31     31   
static TESTPOSTNOPAYLOADOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    TESTPOSTNOPAYLOADOUTPUT_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&TESTPOSTNOPAYLOADOUTPUT_MEMBER_TEST_ID],
   35     35   
);
   36     36   
impl TestPostNoPayloadOutput {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTPOSTNOPAYLOADOUTPUT_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for TestPostNoPayloadOutput {
   41     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     42   
    fn serialize_members(
   43     43   
        &self,
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        if let Some(ref val) = self.test_id {
   47     47   
            ser.write_string(&TESTPOSTNOPAYLOADOUTPUT_MEMBER_TEST_ID, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl TestPostNoPayloadOutput {
   53     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     57   
        #[allow(unused_variables, unused_mut)]
   58     58   
        let mut builder = Self::builder();
   59     59   
        #[allow(
   60     60   
            unused_variables,
   61     61   
            unreachable_code,
   62     62   
            clippy::single_match,
   63     63   
            clippy::match_single_binding,
   64     64   
            clippy::diverging_sub_expression
   65     65   
        )]
   66         -
        deserializer.read_struct(&TESTPOSTNOPAYLOADOUTPUT_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&TESTPOSTNOPAYLOADOUTPUT_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.test_id = Some(deser.read_string(member)?);
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl TestPostNoPayloadOutput {
          79  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          80  +
    /// Header-bound members are read directly from headers, avoiding runtime
          81  +
    /// member iteration overhead. Body members are read via the deserializer.
          82  +
    pub fn deserialize_with_response(
          83  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          84  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          85  +
        _status: u16,
          86  +
        _body: &[u8],
          87  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          88  +
        #[allow(unused_variables, unused_mut)]
          89  +
        let mut builder = Self::builder();
          90  +
        if let Some(val) = headers.get("X-Amz-Test-Id") {
          91  +
            builder.test_id = Some(val.to_string());
          92  +
        }
          93  +
        Ok(builder.build())
          94  +
    }
          95  +
}
   78     96   
impl TestPostNoPayloadOutput {
   79     97   
    /// Creates a new builder-style object to manufacture [`TestPostNoPayloadOutput`](crate::operation::test_post_no_payload::TestPostNoPayloadOutput).
   80     98   
    pub fn builder() -> crate::operation::test_post_no_payload::builders::TestPostNoPayloadOutputBuilder {
   81     99   
        crate::operation::test_post_no_payload::builders::TestPostNoPayloadOutputBuilder::default()
   82    100   
    }
   83    101   
}
   84    102   
   85    103   
/// A builder for [`TestPostNoPayloadOutput`](crate::operation::test_post_no_payload::TestPostNoPayloadOutput).
   86    104   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   87    105   
#[non_exhaustive]

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

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `TimestampFormatHeaders`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct TimestampFormatHeaders;
    6      6   
impl TimestampFormatHeaders {
    7      7   
    /// Creates a new `TimestampFormatHeaders`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::timestamp_format_headers::TimestampFormatHeadersInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::timestamp_format_headers::TimestampFormatHeadersOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::timestamp_format_headers::TimestampFormatHeadersInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::timestamp_format_headers::TimestampFormatHeadersOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::timestamp_format_headers::TimestampFormatHeadersError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -110,114 +229,239 @@
  130    134   
                crate::operation::timestamp_format_headers::TimestampFormatHeadersError,
  131    135   
            >::new());
  132    136   
  133    137   
        ::std::borrow::Cow::Owned(rcb)
  134    138   
    }
  135    139   
}
  136    140   
  137    141   
#[derive(Debug)]
  138    142   
struct TimestampFormatHeadersResponseDeserializer;
  139    143   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for TimestampFormatHeadersResponseDeserializer {
  140         -
    fn deserialize_nonstreaming(
         144  +
    fn deserialize_nonstreaming_with_config(
  141    145   
        &self,
  142    146   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         147  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  143    148   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  144    149   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
         150  +
        #[allow(unused_mut)]
         151  +
        let mut force_error = false;
         152  +
         153  +
        if !success && status != 200 || force_error {
  145    154   
            let headers = response.headers();
  146    155   
            let body = response.body().bytes().expect("body loaded");
  147    156   
            #[allow(unused_mut)]
  148         -
        let mut force_error = false;
         157  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         158  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         159  +
            })?;
  149    160   
  150         -
        let parse_result = if !success && status != 200 || force_error {
  151         -
            crate::protocol_serde::shape_timestamp_format_headers::de_timestamp_format_headers_http_error(status, headers, body)
         161  +
            let generic = generic_builder.build();
         162  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         163  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
         164  +
                    crate::operation::timestamp_format_headers::TimestampFormatHeadersError::generic(generic),
         165  +
                ),
         166  +
            ))
  152    167   
        } else {
  153         -
            crate::protocol_serde::shape_timestamp_format_headers::de_timestamp_format_headers_http_response(status, headers, body)
  154         -
        };
  155         -
        crate::protocol_serde::type_erase_result(parse_result)
         168  +
            let protocol = _cfg
         169  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         170  +
                .expect("a SharedClientProtocol is required");
         171  +
            let mut deser = protocol
         172  +
                .deserialize_response(response, TimestampFormatHeaders::OUTPUT_SCHEMA, _cfg)
         173  +
                .map_err(|e| {
         174  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         175  +
                })?;
         176  +
            let body = response.body().bytes().expect("body loaded");
         177  +
            let output = crate::operation::timestamp_format_headers::TimestampFormatHeadersOutput::deserialize_with_response(
         178  +
                &mut *deser,
         179  +
                response.headers(),
         180  +
                response.status().into(),
         181  +
                body,
         182  +
            )
         183  +
            .map_err(|e| {
         184  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         185  +
            })?;
         186  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         187  +
        }
  156    188   
    }
  157    189   
}
  158    190   
#[derive(Debug)]
  159    191   
struct TimestampFormatHeadersRequestSerializer;
  160    192   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for TimestampFormatHeadersRequestSerializer {
  161    193   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  162    194   
    fn serialize_input(
  163    195   
        &self,
  164    196   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  165    197   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  166    198   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  167    199   
        let input = input
  168    200   
            .downcast::<crate::operation::timestamp_format_headers::TimestampFormatHeadersInput>()
  169    201   
            .expect("correct type");
  170         -
        let _header_serialization_settings = _cfg
  171         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  172         -
            .cloned()
  173         -
            .unwrap_or_default();
  174         -
        let mut request_builder = {
  175         -
            #[allow(clippy::uninlined_format_args)]
  176         -
            fn uri_base(
  177         -
                _input: &crate::operation::timestamp_format_headers::TimestampFormatHeadersInput,
  178         -
                output: &mut ::std::string::String,
  179         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  180         -
                use ::std::fmt::Write as _;
  181         -
                ::std::write!(output, "/TimestampFormatHeaders").expect("formatting should succeed");
  182         -
                ::std::result::Result::Ok(())
  183         -
            }
  184         -
            #[allow(clippy::unnecessary_wraps)]
  185         -
            fn update_http_builder(
  186         -
                input: &crate::operation::timestamp_format_headers::TimestampFormatHeadersInput,
  187         -
                builder: ::http_1x::request::Builder,
  188         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  189         -
                let mut uri = ::std::string::String::new();
  190         -
                uri_base(input, &mut uri)?;
  191         -
                let builder = crate::protocol_serde::shape_timestamp_format_headers::ser_timestamp_format_headers_headers(input, builder)?;
  192         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  193         -
            }
  194         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  195         -
            builder
  196         -
        };
  197         -
        let body = ::aws_smithy_types::body::SdkBody::from("");
         202  +
        let protocol = _cfg
         203  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         204  +
            .expect("a SharedClientProtocol is required");
         205  +
        let mut request = protocol
         206  +
            .serialize_request(&input, TimestampFormatHeaders::INPUT_SCHEMA, "", _cfg)
         207  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
  198    208   
  199         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         209  +
        return ::std::result::Result::Ok(request);
  200    210   
    }
  201    211   
}
  202    212   
#[derive(Debug)]
  203    213   
struct TimestampFormatHeadersEndpointParamsInterceptor;
  204    214   
  205    215   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TimestampFormatHeadersEndpointParamsInterceptor {
  206    216   
    fn name(&self) -> &'static str {
  207    217   
        "TimestampFormatHeadersEndpointParamsInterceptor"
  208    218   
    }
  209    219
@@ -329,339 +389,409 @@
  349    359   
            .expect("the config must have a deserializer");
  350    360   
  351    361   
        let parsed = de.deserialize_streaming(&mut http_response);
  352    362   
        let parsed = parsed.unwrap_or_else(|| {
  353    363   
            let http_response = http_response.map(|body| {
  354    364   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  355    365   
                    body.bytes().unwrap(),
  356    366   
                    ::aws_smithy_protocol_test::MediaType::from("unknown"),
  357    367   
                )))
  358    368   
            });
  359         -
            de.deserialize_nonstreaming(&http_response)
         369  +
            // Build a config bag with the protocol for schema-based deserialization
         370  +
            #[allow(unused_mut)]
         371  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         372  +
            {
         373  +
                let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
         374  +
                layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
         375  +
                    ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
         376  +
                ));
         377  +
                test_cfg.push_shared_layer(layer.freeze());
         378  +
            }
         379  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  360    380   
        });
  361    381   
        let parsed = parsed
  362    382   
            .expect("should be successful response")
  363    383   
            .downcast::<crate::operation::timestamp_format_headers::TimestampFormatHeadersOutput>()
  364    384   
            .unwrap();
  365    385   
        ::pretty_assertions::assert_eq!(
  366    386   
            parsed.member_epoch_seconds,
  367    387   
            expected_output.member_epoch_seconds,
  368    388   
            "Unexpected value for `member_epoch_seconds`"
  369    389   
        );

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

@@ -33,33 +258,300 @@
   53     53   
    "aws.protocoltests.restjson.synthetic",
   54     54   
    "TimestampFormatHeadersInput",
   55     55   
);
   56     56   
static TIMESTAMPFORMATHEADERSINPUT_MEMBER_MEMBER_EPOCH_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "aws.protocoltests.restjson.synthetic#TimestampFormatHeadersInput$memberEpochSeconds",
   59     59   
        "aws.protocoltests.restjson.synthetic",
   60     60   
        "TimestampFormatHeadersInput",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::Timestamp,
   63         -
    "member_epoch_seconds",
          63  +
    "memberEpochSeconds",
   64     64   
    0,
   65     65   
)
   66     66   
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::EpochSeconds)
   67     67   
.with_http_header("X-memberEpochSeconds");
   68     68   
static TIMESTAMPFORMATHEADERSINPUT_MEMBER_MEMBER_HTTP_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "aws.protocoltests.restjson.synthetic#TimestampFormatHeadersInput$memberHttpDate",
   71     71   
        "aws.protocoltests.restjson.synthetic",
   72     72   
        "TimestampFormatHeadersInput",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::Timestamp,
   75         -
    "member_http_date",
          75  +
    "memberHttpDate",
   76     76   
    1,
   77     77   
)
   78     78   
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::HttpDate)
   79     79   
.with_http_header("X-memberHttpDate");
   80     80   
static TIMESTAMPFORMATHEADERSINPUT_MEMBER_MEMBER_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static(
   82     82   
        "aws.protocoltests.restjson.synthetic#TimestampFormatHeadersInput$memberDateTime",
   83     83   
        "aws.protocoltests.restjson.synthetic",
   84     84   
        "TimestampFormatHeadersInput",
   85     85   
    ),
   86     86   
    ::aws_smithy_schema::ShapeType::Timestamp,
   87         -
    "member_date_time",
          87  +
    "memberDateTime",
   88     88   
    2,
   89     89   
)
   90     90   
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime)
   91     91   
.with_http_header("X-memberDateTime");
   92     92   
static TIMESTAMPFORMATHEADERSINPUT_MEMBER_DEFAULT_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "aws.protocoltests.restjson.synthetic#TimestampFormatHeadersInput$defaultFormat",
   95     95   
        "aws.protocoltests.restjson.synthetic",
   96     96   
        "TimestampFormatHeadersInput",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::Timestamp,
   99         -
    "default_format",
          99  +
    "defaultFormat",
  100    100   
    3,
  101    101   
)
  102    102   
.with_http_header("X-defaultFormat");
  103    103   
static TIMESTAMPFORMATHEADERSINPUT_MEMBER_TARGET_EPOCH_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "aws.protocoltests.restjson.synthetic#TimestampFormatHeadersInput$targetEpochSeconds",
  106    106   
        "aws.protocoltests.restjson.synthetic",
  107    107   
        "TimestampFormatHeadersInput",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::Timestamp,
  110         -
    "target_epoch_seconds",
         110  +
    "targetEpochSeconds",
  111    111   
    4,
  112    112   
)
  113         -
.with_http_header("X-targetEpochSeconds");
         113  +
.with_http_header("X-targetEpochSeconds")
         114  +
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::EpochSeconds);
  114    115   
static TIMESTAMPFORMATHEADERSINPUT_MEMBER_TARGET_HTTP_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    116   
    ::aws_smithy_schema::ShapeId::from_static(
  116    117   
        "aws.protocoltests.restjson.synthetic#TimestampFormatHeadersInput$targetHttpDate",
  117    118   
        "aws.protocoltests.restjson.synthetic",
  118    119   
        "TimestampFormatHeadersInput",
  119    120   
    ),
  120    121   
    ::aws_smithy_schema::ShapeType::Timestamp,
  121         -
    "target_http_date",
         122  +
    "targetHttpDate",
  122    123   
    5,
  123    124   
)
  124         -
.with_http_header("X-targetHttpDate");
         125  +
.with_http_header("X-targetHttpDate")
         126  +
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::HttpDate);
  125    127   
static TIMESTAMPFORMATHEADERSINPUT_MEMBER_TARGET_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    128   
    ::aws_smithy_schema::ShapeId::from_static(
  127    129   
        "aws.protocoltests.restjson.synthetic#TimestampFormatHeadersInput$targetDateTime",
  128    130   
        "aws.protocoltests.restjson.synthetic",
  129    131   
        "TimestampFormatHeadersInput",
  130    132   
    ),
  131    133   
    ::aws_smithy_schema::ShapeType::Timestamp,
  132         -
    "target_date_time",
         134  +
    "targetDateTime",
  133    135   
    6,
  134    136   
)
  135         -
.with_http_header("X-targetDateTime");
         137  +
.with_http_header("X-targetDateTime")
         138  +
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
  136    139   
static TIMESTAMPFORMATHEADERSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  137    140   
    TIMESTAMPFORMATHEADERSINPUT_SCHEMA_ID,
  138    141   
    ::aws_smithy_schema::ShapeType::Structure,
  139    142   
    &[
  140    143   
        &TIMESTAMPFORMATHEADERSINPUT_MEMBER_MEMBER_EPOCH_SECONDS,
  141    144   
        &TIMESTAMPFORMATHEADERSINPUT_MEMBER_MEMBER_HTTP_DATE,
  142    145   
        &TIMESTAMPFORMATHEADERSINPUT_MEMBER_MEMBER_DATE_TIME,
  143    146   
        &TIMESTAMPFORMATHEADERSINPUT_MEMBER_DEFAULT_FORMAT,
  144    147   
        &TIMESTAMPFORMATHEADERSINPUT_MEMBER_TARGET_EPOCH_SECONDS,
  145    148   
        &TIMESTAMPFORMATHEADERSINPUT_MEMBER_TARGET_HTTP_DATE,
  146    149   
        &TIMESTAMPFORMATHEADERSINPUT_MEMBER_TARGET_DATE_TIME,
  147    150   
    ],
  148         -
);
         151  +
)
         152  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/TimestampFormatHeaders", None));
  149    153   
impl TimestampFormatHeadersInput {
  150    154   
    /// The schema for this shape.
  151    155   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TIMESTAMPFORMATHEADERSINPUT_SCHEMA;
  152    156   
}
  153    157   
impl ::aws_smithy_schema::serde::SerializableStruct for TimestampFormatHeadersInput {
  154    158   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  155    159   
    fn serialize_members(
  156    160   
        &self,
  157    161   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  158    162   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  159    163   
        if let Some(ref val) = self.member_epoch_seconds {
  160    164   
            ser.write_timestamp(&TIMESTAMPFORMATHEADERSINPUT_MEMBER_MEMBER_EPOCH_SECONDS, val)?;
  161    165   
        }
  162    166   
        if let Some(ref val) = self.member_http_date {
  163    167   
            ser.write_timestamp(&TIMESTAMPFORMATHEADERSINPUT_MEMBER_MEMBER_HTTP_DATE, val)?;
  164    168   
        }
  165    169   
        if let Some(ref val) = self.member_date_time {
  166    170   
            ser.write_timestamp(&TIMESTAMPFORMATHEADERSINPUT_MEMBER_MEMBER_DATE_TIME, val)?;
  167    171   
        }
  168    172   
        if let Some(ref val) = self.default_format {
  169    173   
            ser.write_timestamp(&TIMESTAMPFORMATHEADERSINPUT_MEMBER_DEFAULT_FORMAT, val)?;
  170    174   
        }
  171    175   
        if let Some(ref val) = self.target_epoch_seconds {
  172    176   
            ser.write_timestamp(&TIMESTAMPFORMATHEADERSINPUT_MEMBER_TARGET_EPOCH_SECONDS, val)?;
  173    177   
        }
  174    178   
        if let Some(ref val) = self.target_http_date {
  175    179   
            ser.write_timestamp(&TIMESTAMPFORMATHEADERSINPUT_MEMBER_TARGET_HTTP_DATE, val)?;
  176    180   
        }
  177    181   
        if let Some(ref val) = self.target_date_time {
  178    182   
            ser.write_timestamp(&TIMESTAMPFORMATHEADERSINPUT_MEMBER_TARGET_DATE_TIME, val)?;
  179    183   
        }
  180    184   
        Ok(())
  181    185   
    }
  182    186   
}
  183    187   
impl TimestampFormatHeadersInput {
  184    188   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  185         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  186         -
        deserializer: &mut D,
         189  +
    pub fn deserialize(
         190  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  187    191   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  188    192   
        #[allow(unused_variables, unused_mut)]
  189    193   
        let mut builder = Self::builder();
  190    194   
        #[allow(
  191    195   
            unused_variables,
  192    196   
            unreachable_code,
  193    197   
            clippy::single_match,
  194    198   
            clippy::match_single_binding,
  195    199   
            clippy::diverging_sub_expression
  196    200   
        )]
  197         -
        deserializer.read_struct(&TIMESTAMPFORMATHEADERSINPUT_SCHEMA, (), |_, member, deser| {
         201  +
        deserializer.read_struct(&TIMESTAMPFORMATHEADERSINPUT_SCHEMA, &mut |member, deser| {
  198    202   
            match member.member_index() {
  199    203   
                Some(0) => {
  200    204   
                    builder.member_epoch_seconds = Some(deser.read_timestamp(member)?);
  201    205   
                }
  202    206   
                Some(1) => {
  203    207   
                    builder.member_http_date = Some(deser.read_timestamp(member)?);
  204    208   
                }
  205    209   
                Some(2) => {
  206    210   
                    builder.member_date_time = Some(deser.read_timestamp(member)?);
  207    211   
                }
  208    212   
                Some(3) => {
  209    213   
                    builder.default_format = Some(deser.read_timestamp(member)?);
  210    214   
                }
  211    215   
                Some(4) => {
  212    216   
                    builder.target_epoch_seconds = Some(deser.read_timestamp(member)?);
  213    217   
                }
  214    218   
                Some(5) => {
  215    219   
                    builder.target_http_date = Some(deser.read_timestamp(member)?);
  216    220   
                }
  217    221   
                Some(6) => {
  218    222   
                    builder.target_date_time = Some(deser.read_timestamp(member)?);
  219    223   
                }
  220    224   
                _ => {}
  221    225   
            }
  222    226   
            Ok(())
  223    227   
        })?;
  224    228   
        builder
  225    229   
            .build()
  226    230   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  227    231   
    }
  228    232   
}
         233  +
impl TimestampFormatHeadersInput {
         234  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         235  +
    /// Header-bound members are read directly from headers, avoiding runtime
         236  +
    /// member iteration overhead. Body members are read via the deserializer.
         237  +
    pub fn deserialize_with_response(
         238  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         239  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         240  +
        _status: u16,
         241  +
        _body: &[u8],
         242  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         243  +
        #[allow(unused_variables, unused_mut)]
         244  +
        let mut builder = Self::builder();
         245  +
        if let Some(val) = headers.get("X-memberEpochSeconds") {
         246  +
            builder.member_epoch_seconds = val.parse::<f64>().ok().map(::aws_smithy_types::DateTime::from_secs_f64);
         247  +
        }
         248  +
        if let Some(val) = headers.get("X-memberHttpDate") {
         249  +
            builder.member_http_date = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
         250  +
        }
         251  +
        if let Some(val) = headers.get("X-memberDateTime") {
         252  +
            builder.member_date_time = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::DateTime).ok();
         253  +
        }
         254  +
        if let Some(val) = headers.get("X-defaultFormat") {
         255  +
            builder.default_format = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
         256  +
        }
         257  +
        if let Some(val) = headers.get("X-targetEpochSeconds") {
         258  +
            builder.target_epoch_seconds = val.parse::<f64>().ok().map(::aws_smithy_types::DateTime::from_secs_f64);
         259  +
        }
         260  +
        if let Some(val) = headers.get("X-targetHttpDate") {
         261  +
            builder.target_http_date = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
         262  +
        }
         263  +
        if let Some(val) = headers.get("X-targetDateTime") {
         264  +
            builder.target_date_time = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::DateTime).ok();
         265  +
        }
         266  +
        builder
         267  +
            .build()
         268  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         269  +
    }
         270  +
}
  229    271   
impl TimestampFormatHeadersInput {
  230    272   
    /// Creates a new builder-style object to manufacture [`TimestampFormatHeadersInput`](crate::operation::timestamp_format_headers::TimestampFormatHeadersInput).
  231    273   
    pub fn builder() -> crate::operation::timestamp_format_headers::builders::TimestampFormatHeadersInputBuilder {
  232    274   
        crate::operation::timestamp_format_headers::builders::TimestampFormatHeadersInputBuilder::default()
  233    275   
    }
  234    276   
}
  235    277   
  236    278   
/// A builder for [`TimestampFormatHeadersInput`](crate::operation::timestamp_format_headers::TimestampFormatHeadersInput).
  237    279   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  238    280   
#[non_exhaustive]