Client Test

Client Test

rev. 32b1b3c3761061baed26023be3219639e42d7d12

Files changed:

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/put_with_content_encoding/_put_with_content_encoding_input.rs

@@ -21,21 +131,173 @@
   41     41   
        "PutWithContentEncodingInput",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::String,
   44     44   
    "data",
   45     45   
    1,
   46     46   
);
   47     47   
static PUTWITHCONTENTENCODINGINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    PUTWITHCONTENTENCODINGINPUT_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[&PUTWITHCONTENTENCODINGINPUT_MEMBER_ENCODING, &PUTWITHCONTENTENCODINGINPUT_MEMBER_DATA],
   51         -
);
          51  +
)
          52  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
          53  +
    "POST",
          54  +
    "/requestcompression/putcontentwithencoding",
          55  +
    None,
          56  +
));
   52     57   
impl PutWithContentEncodingInput {
   53     58   
    /// The schema for this shape.
   54     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTWITHCONTENTENCODINGINPUT_SCHEMA;
   55     60   
}
   56     61   
impl ::aws_smithy_schema::serde::SerializableStruct for PutWithContentEncodingInput {
   57     62   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   58     63   
    fn serialize_members(
   59     64   
        &self,
   60     65   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   61     66   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   62     67   
        if let Some(ref val) = self.encoding {
   63     68   
            ser.write_string(&PUTWITHCONTENTENCODINGINPUT_MEMBER_ENCODING, val)?;
   64     69   
        }
   65     70   
        if let Some(ref val) = self.data {
   66     71   
            ser.write_string(&PUTWITHCONTENTENCODINGINPUT_MEMBER_DATA, val)?;
   67     72   
        }
   68     73   
        Ok(())
   69     74   
    }
   70     75   
}
   71     76   
impl PutWithContentEncodingInput {
   72     77   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   73         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   74         -
        deserializer: &mut D,
          78  +
    pub fn deserialize(
          79  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   75     80   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   76     81   
        #[allow(unused_variables, unused_mut)]
   77     82   
        let mut builder = Self::builder();
   78     83   
        #[allow(
   79     84   
            unused_variables,
   80     85   
            unreachable_code,
   81     86   
            clippy::single_match,
   82     87   
            clippy::match_single_binding,
   83     88   
            clippy::diverging_sub_expression
   84     89   
        )]
   85         -
        deserializer.read_struct(&PUTWITHCONTENTENCODINGINPUT_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&PUTWITHCONTENTENCODINGINPUT_SCHEMA, &mut |member, deser| {
   86     91   
            match member.member_index() {
   87     92   
                Some(0) => {
   88     93   
                    builder.encoding = Some(deser.read_string(member)?);
   89     94   
                }
   90     95   
                Some(1) => {
   91     96   
                    builder.data = Some(deser.read_string(member)?);
   92     97   
                }
   93     98   
                _ => {}
   94     99   
            }
   95    100   
            Ok(())
   96    101   
        })?;
   97    102   
        builder
   98    103   
            .build()
   99    104   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  100    105   
    }
  101    106   
}
         107  +
impl PutWithContentEncodingInput {
         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("Content-Encoding") {
         120  +
            builder.encoding = Some(val.to_string());
         121  +
        }
         122  +
        #[allow(
         123  +
            unused_variables,
         124  +
            unreachable_code,
         125  +
            clippy::single_match,
         126  +
            clippy::match_single_binding,
         127  +
            clippy::diverging_sub_expression
         128  +
        )]
         129  +
        deserializer.read_struct(&PUTWITHCONTENTENCODINGINPUT_SCHEMA, &mut |member, deser| {
         130  +
            match member.member_index() {
         131  +
                Some(0) => { /* read from headers above */ }
         132  +
                Some(1) => {
         133  +
                    builder.data = Some(deser.read_string(member)?);
         134  +
                }
         135  +
                _ => {}
         136  +
            }
         137  +
            Ok(())
         138  +
        })?;
         139  +
        builder
         140  +
            .build()
         141  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         142  +
    }
         143  +
}
  102    144   
impl PutWithContentEncodingInput {
  103    145   
    /// Creates a new builder-style object to manufacture [`PutWithContentEncodingInput`](crate::operation::put_with_content_encoding::PutWithContentEncodingInput).
  104    146   
    pub fn builder() -> crate::operation::put_with_content_encoding::builders::PutWithContentEncodingInputBuilder {
  105    147   
        crate::operation::put_with_content_encoding::builders::PutWithContentEncodingInputBuilder::default()
  106    148   
    }
  107    149   
}
  108    150   
  109    151   
/// A builder for [`PutWithContentEncodingInput`](crate::operation::put_with_content_encoding::PutWithContentEncodingInput).
  110    152   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  111    153   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/put_with_content_encoding/_put_with_content_encoding_output.rs

@@ -1,1 +65,76 @@
   18     18   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   19     19   
    fn serialize_members(
   20     20   
        &self,
   21     21   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   22     22   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   23     23   
        Ok(())
   24     24   
    }
   25     25   
}
   26     26   
impl PutWithContentEncodingOutput {
   27     27   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   28         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   29         -
        deserializer: &mut D,
          28  +
    pub fn deserialize(
          29  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   30     30   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   31     31   
        #[allow(unused_variables, unused_mut)]
   32     32   
        let mut builder = Self::builder();
   33     33   
        #[allow(
   34     34   
            unused_variables,
   35     35   
            unreachable_code,
   36     36   
            clippy::single_match,
   37     37   
            clippy::match_single_binding,
   38     38   
            clippy::diverging_sub_expression
   39     39   
        )]
   40         -
        deserializer.read_struct(&PUTWITHCONTENTENCODINGOUTPUT_SCHEMA, (), |_, member, deser| {
          40  +
        deserializer.read_struct(&PUTWITHCONTENTENCODINGOUTPUT_SCHEMA, &mut |member, deser| {
   41     41   
            match member.member_index() {
   42     42   
                _ => {}
   43     43   
            }
   44     44   
            Ok(())
   45     45   
        })?;
   46     46   
        Ok(builder.build())
   47     47   
    }
   48     48   
}
          49  +
impl PutWithContentEncodingOutput {
          50  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          51  +
    pub fn deserialize_with_response(
          52  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          53  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          54  +
        _status: u16,
          55  +
        _body: &[u8],
          56  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          57  +
        Ok(Self::builder().build())
          58  +
    }
          59  +
}
   49     60   
impl PutWithContentEncodingOutput {
   50     61   
    /// Creates a new builder-style object to manufacture [`PutWithContentEncodingOutput`](crate::operation::put_with_content_encoding::PutWithContentEncodingOutput).
   51     62   
    pub fn builder() -> crate::operation::put_with_content_encoding::builders::PutWithContentEncodingOutputBuilder {
   52     63   
        crate::operation::put_with_content_encoding::builders::PutWithContentEncodingOutputBuilder::default()
   53     64   
    }
   54     65   
}
   55     66   
   56     67   
/// A builder for [`PutWithContentEncodingOutput`](crate::operation::put_with_content_encoding::PutWithContentEncodingOutput).
   57     68   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   58     69   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/query_idempotency_token_auto_fill.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 `QueryIdempotencyTokenAutoFill`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct QueryIdempotencyTokenAutoFill;
    6      6   
impl QueryIdempotencyTokenAutoFill {
    7      7   
    /// Creates a new `QueryIdempotencyTokenAutoFill`
    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::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillOutput::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::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -118,124 +180,187 @@
  138    144   
                crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillError,
  139    145   
            >::new());
  140    146   
  141    147   
        ::std::borrow::Cow::Owned(rcb)
  142    148   
    }
  143    149   
}
  144    150   
  145    151   
#[derive(Debug)]
  146    152   
struct QueryIdempotencyTokenAutoFillResponseDeserializer;
  147    153   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for QueryIdempotencyTokenAutoFillResponseDeserializer {
  148         -
    fn deserialize_nonstreaming(
         154  +
    fn deserialize_nonstreaming_with_config(
  149    155   
        &self,
  150    156   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         157  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    158   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    159   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153    160   
        let headers = response.headers();
  154    161   
        let body = response.body().bytes().expect("body loaded");
  155    162   
        #[allow(unused_mut)]
  156    163   
        let mut force_error = false;
  157    164   
  158    165   
        let parse_result = if !success && status != 200 || force_error {
  159    166   
            crate::protocol_serde::shape_query_idempotency_token_auto_fill::de_query_idempotency_token_auto_fill_http_error(status, headers, body)
  160    167   
        } else {

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/query_idempotency_token_auto_fill/_query_idempotency_token_auto_fill_input.rs

@@ -5,5 +109,121 @@
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27     27   
    "token",
   28     28   
    0,
   29     29   
)
   30     30   
.with_http_query("token");
   31     31   
static QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_MEMBER_TOKEN],
   35         -
);
          35  +
)
          36  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/QueryIdempotencyTokenAutoFill", None));
   36     37   
impl QueryIdempotencyTokenAutoFillInput {
   37     38   
    /// The schema for this shape.
   38     39   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_SCHEMA;
   39     40   
}
   40     41   
impl ::aws_smithy_schema::serde::SerializableStruct for QueryIdempotencyTokenAutoFillInput {
   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.token {
   47     48   
            ser.write_string(&QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_MEMBER_TOKEN, val)?;
   48     49   
        }
   49     50   
        Ok(())
   50     51   
    }
   51     52   
}
   52     53   
impl QueryIdempotencyTokenAutoFillInput {
   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(&QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_SCHEMA, &mut |member, deser| {
   67     68   
            match member.member_index() {
   68     69   
                Some(0) => {
   69     70   
                    builder.token = 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 QueryIdempotencyTokenAutoFillInput {
          82  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          83  +
    pub fn deserialize_with_response(
          84  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          85  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          86  +
        _status: u16,
          87  +
        _body: &[u8],
          88  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          89  +
        Self::deserialize(deserializer)
          90  +
    }
          91  +
}
   80     92   
impl QueryIdempotencyTokenAutoFillInput {
   81     93   
    /// Creates a new builder-style object to manufacture [`QueryIdempotencyTokenAutoFillInput`](crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillInput).
   82     94   
    pub fn builder() -> crate::operation::query_idempotency_token_auto_fill::builders::QueryIdempotencyTokenAutoFillInputBuilder {
   83     95   
        crate::operation::query_idempotency_token_auto_fill::builders::QueryIdempotencyTokenAutoFillInputBuilder::default()
   84     96   
    }
   85     97   
}
   86     98   
   87     99   
/// A builder for [`QueryIdempotencyTokenAutoFillInput`](crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillInput).
   88    100   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   89    101   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/query_idempotency_token_auto_fill/_query_idempotency_token_auto_fill_output.rs

@@ -1,1 +68,79 @@
   21     21   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   22     22   
    fn serialize_members(
   23     23   
        &self,
   24     24   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   25     25   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   26     26   
        Ok(())
   27     27   
    }
   28     28   
}
   29     29   
impl QueryIdempotencyTokenAutoFillOutput {
   30     30   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   31         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   32         -
        deserializer: &mut D,
          31  +
    pub fn deserialize(
          32  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   33     33   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   34     34   
        #[allow(unused_variables, unused_mut)]
   35     35   
        let mut builder = Self::builder();
   36     36   
        #[allow(
   37     37   
            unused_variables,
   38     38   
            unreachable_code,
   39     39   
            clippy::single_match,
   40     40   
            clippy::match_single_binding,
   41     41   
            clippy::diverging_sub_expression
   42     42   
        )]
   43         -
        deserializer.read_struct(&QUERYIDEMPOTENCYTOKENAUTOFILLOUTPUT_SCHEMA, (), |_, member, deser| {
          43  +
        deserializer.read_struct(&QUERYIDEMPOTENCYTOKENAUTOFILLOUTPUT_SCHEMA, &mut |member, deser| {
   44     44   
            match member.member_index() {
   45     45   
                _ => {}
   46     46   
            }
   47     47   
            Ok(())
   48     48   
        })?;
   49     49   
        Ok(builder.build())
   50     50   
    }
   51     51   
}
          52  +
impl QueryIdempotencyTokenAutoFillOutput {
          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  +
        Ok(Self::builder().build())
          61  +
    }
          62  +
}
   52     63   
impl QueryIdempotencyTokenAutoFillOutput {
   53     64   
    /// Creates a new builder-style object to manufacture [`QueryIdempotencyTokenAutoFillOutput`](crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillOutput).
   54     65   
    pub fn builder() -> crate::operation::query_idempotency_token_auto_fill::builders::QueryIdempotencyTokenAutoFillOutputBuilder {
   55     66   
        crate::operation::query_idempotency_token_auto_fill::builders::QueryIdempotencyTokenAutoFillOutputBuilder::default()
   56     67   
    }
   57     68   
}
   58     69   
   59     70   
/// A builder for [`QueryIdempotencyTokenAutoFillOutput`](crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillOutput).
   60     71   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   61     72   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/query_params_as_string_list_map.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 `QueryParamsAsStringListMap`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct QueryParamsAsStringListMap;
    6      6   
impl QueryParamsAsStringListMap {
    7      7   
    /// Creates a new `QueryParamsAsStringListMap`
    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::query_params_as_string_list_map::QueryParamsAsStringListMapInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapOutput::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::query_params_as_string_list_map::QueryParamsAsStringListMapInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -110,116 +172,179 @@
  130    136   
                crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapError,
  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 QueryParamsAsStringListMapResponseDeserializer;
  139    145   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for QueryParamsAsStringListMapResponseDeserializer {
  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());
  145    152   
        let headers = response.headers();
  146    153   
        let body = response.body().bytes().expect("body loaded");
  147    154   
        #[allow(unused_mut)]
  148    155   
        let mut force_error = false;
  149    156   
  150    157   
        let parse_result = if !success && status != 200 || force_error {
  151    158   
            crate::protocol_serde::shape_query_params_as_string_list_map::de_query_params_as_string_list_map_http_error(status, headers, body)
  152    159   
        } else {

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/query_params_as_string_list_map/_query_params_as_string_list_map_input.rs

@@ -22,22 +151,176 @@
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Map,
   44     44   
    "foo",
   45     45   
    1,
   46     46   
)
   47     47   
.with_http_query_params();
   48     48   
static QUERYPARAMSASSTRINGLISTMAPINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    QUERYPARAMSASSTRINGLISTMAPINPUT_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[&QUERYPARAMSASSTRINGLISTMAPINPUT_MEMBER_QUX, &QUERYPARAMSASSTRINGLISTMAPINPUT_MEMBER_FOO],
   52         -
);
          52  +
)
          53  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/StringListMap", None));
   53     54   
impl QueryParamsAsStringListMapInput {
   54     55   
    /// The schema for this shape.
   55     56   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYPARAMSASSTRINGLISTMAPINPUT_SCHEMA;
   56     57   
}
   57     58   
impl ::aws_smithy_schema::serde::SerializableStruct for QueryParamsAsStringListMapInput {
   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.qux {
   64     65   
            ser.write_string(&QUERYPARAMSASSTRINGLISTMAPINPUT_MEMBER_QUX, val)?;
   65     66   
        }
   66     67   
        if let Some(ref val) = self.foo {
   67     68   
            ser.write_map(
   68     69   
                &QUERYPARAMSASSTRINGLISTMAPINPUT_MEMBER_FOO,
   69     70   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   70     71   
                    for (key, value) in val {
   71     72   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   72         -
                        todo!("schema: unsupported map value type");
          73  +
          74  +
                        ser.write_list(
          75  +
                            &::aws_smithy_schema::prelude::DOCUMENT,
          76  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
          77  +
                                for item in value {
          78  +
                                    ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
          79  +
                                }
          80  +
                                Ok(())
          81  +
                            },
          82  +
                        )?;
   73     83   
                    }
   74     84   
                    Ok(())
   75     85   
                },
   76     86   
            )?;
   77     87   
        }
   78     88   
        Ok(())
   79     89   
    }
   80     90   
}
   81     91   
impl QueryParamsAsStringListMapInput {
   82     92   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   83         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   84         -
        deserializer: &mut D,
          93  +
    pub fn deserialize(
          94  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   85     95   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   86     96   
        #[allow(unused_variables, unused_mut)]
   87     97   
        let mut builder = Self::builder();
   88     98   
        #[allow(
   89     99   
            unused_variables,
   90    100   
            unreachable_code,
   91    101   
            clippy::single_match,
   92    102   
            clippy::match_single_binding,
   93    103   
            clippy::diverging_sub_expression
   94    104   
        )]
   95         -
        deserializer.read_struct(&QUERYPARAMSASSTRINGLISTMAPINPUT_SCHEMA, (), |_, member, deser| {
         105  +
        deserializer.read_struct(&QUERYPARAMSASSTRINGLISTMAPINPUT_SCHEMA, &mut |member, deser| {
   96    106   
            match member.member_index() {
   97    107   
                Some(0) => {
   98    108   
                    builder.qux = Some(deser.read_string(member)?);
   99    109   
                }
  100    110   
                Some(1) => {
  101    111   
                    builder.foo = Some({
  102         -
                        let container = if let Some(cap) = deser.container_size() {
  103         -
                            std::collections::HashMap::with_capacity(cap)
  104         -
                        } else {
  105         -
                            std::collections::HashMap::new()
  106         -
                        };
  107         -
                        deser.read_map(member, container, |mut map, key, deser| {
  108         -
                            map.insert(key, todo!("deserialize nested aggregate"));
  109         -
                            Ok(map)
  110         -
                        })?
         112  +
                        let mut container = std::collections::HashMap::new();
         113  +
                        deser.read_map(member, &mut |key, deser| {
         114  +
                            container.insert(key, {
         115  +
                                let mut list = Vec::new();
         116  +
                                deser.read_list(member, &mut |deser| {
         117  +
                                    list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
         118  +
                                    Ok(())
         119  +
                                })?;
         120  +
                                list
         121  +
                            });
         122  +
                            Ok(())
         123  +
                        })?;
         124  +
                        container
  111    125   
                    });
  112    126   
                }
  113    127   
                _ => {}
  114    128   
            }
  115    129   
            Ok(())
  116    130   
        })?;
  117    131   
        builder
  118    132   
            .build()
  119    133   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  120    134   
    }
  121    135   
}
         136  +
impl QueryParamsAsStringListMapInput {
         137  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         138  +
    pub fn deserialize_with_response(
         139  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         140  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         141  +
        _status: u16,
         142  +
        _body: &[u8],
         143  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         144  +
        Self::deserialize(deserializer)
         145  +
    }
         146  +
}
  122    147   
impl QueryParamsAsStringListMapInput {
  123    148   
    /// Creates a new builder-style object to manufacture [`QueryParamsAsStringListMapInput`](crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapInput).
  124    149   
    pub fn builder() -> crate::operation::query_params_as_string_list_map::builders::QueryParamsAsStringListMapInputBuilder {
  125    150   
        crate::operation::query_params_as_string_list_map::builders::QueryParamsAsStringListMapInputBuilder::default()
  126    151   
    }
  127    152   
}
  128    153   
  129    154   
/// A builder for [`QueryParamsAsStringListMapInput`](crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapInput).
  130    155   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  131    156   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/query_params_as_string_list_map/_query_params_as_string_list_map_output.rs

@@ -1,1 +65,76 @@
   18     18   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   19     19   
    fn serialize_members(
   20     20   
        &self,
   21     21   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   22     22   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   23     23   
        Ok(())
   24     24   
    }
   25     25   
}
   26     26   
impl QueryParamsAsStringListMapOutput {
   27     27   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   28         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   29         -
        deserializer: &mut D,
          28  +
    pub fn deserialize(
          29  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   30     30   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   31     31   
        #[allow(unused_variables, unused_mut)]
   32     32   
        let mut builder = Self::builder();
   33     33   
        #[allow(
   34     34   
            unused_variables,
   35     35   
            unreachable_code,
   36     36   
            clippy::single_match,
   37     37   
            clippy::match_single_binding,
   38     38   
            clippy::diverging_sub_expression
   39     39   
        )]
   40         -
        deserializer.read_struct(&QUERYPARAMSASSTRINGLISTMAPOUTPUT_SCHEMA, (), |_, member, deser| {
          40  +
        deserializer.read_struct(&QUERYPARAMSASSTRINGLISTMAPOUTPUT_SCHEMA, &mut |member, deser| {
   41     41   
            match member.member_index() {
   42     42   
                _ => {}
   43     43   
            }
   44     44   
            Ok(())
   45     45   
        })?;
   46     46   
        Ok(builder.build())
   47     47   
    }
   48     48   
}
          49  +
impl QueryParamsAsStringListMapOutput {
          50  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          51  +
    pub fn deserialize_with_response(
          52  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          53  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          54  +
        _status: u16,
          55  +
        _body: &[u8],
          56  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          57  +
        Ok(Self::builder().build())
          58  +
    }
          59  +
}
   49     60   
impl QueryParamsAsStringListMapOutput {
   50     61   
    /// Creates a new builder-style object to manufacture [`QueryParamsAsStringListMapOutput`](crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapOutput).
   51     62   
    pub fn builder() -> crate::operation::query_params_as_string_list_map::builders::QueryParamsAsStringListMapOutputBuilder {
   52     63   
        crate::operation::query_params_as_string_list_map::builders::QueryParamsAsStringListMapOutputBuilder::default()
   53     64   
    }
   54     65   
}
   55     66   
   56     67   
/// A builder for [`QueryParamsAsStringListMapOutput`](crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapOutput).
   57     68   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   58     69   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/query_precedence.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 `QueryPrecedence`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct QueryPrecedence;
    6      6   
impl QueryPrecedence {
    7      7   
    /// Creates a new `QueryPrecedence`
    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::query_precedence::QueryPrecedenceInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::query_precedence::QueryPrecedenceOutput::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::query_precedence::QueryPrecedenceInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::query_precedence::QueryPrecedenceOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::query_precedence::QueryPrecedenceError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -104,108 +166,171 @@
  124    128   
                crate::operation::query_precedence::QueryPrecedenceError,
  125    129   
            >::new());
  126    130   
  127    131   
        ::std::borrow::Cow::Owned(rcb)
  128    132   
    }
  129    133   
}
  130    134   
  131    135   
#[derive(Debug)]
  132    136   
struct QueryPrecedenceResponseDeserializer;
  133    137   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for QueryPrecedenceResponseDeserializer {
  134         -
    fn deserialize_nonstreaming(
         138  +
    fn deserialize_nonstreaming_with_config(
  135    139   
        &self,
  136    140   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         141  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  137    142   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  138    143   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  139    144   
        let headers = response.headers();
  140    145   
        let body = response.body().bytes().expect("body loaded");
  141    146   
        #[allow(unused_mut)]
  142    147   
        let mut force_error = false;
  143    148   
  144    149   
        let parse_result = if !success && status != 200 || force_error {
  145    150   
            crate::protocol_serde::shape_query_precedence::de_query_precedence_http_error(status, headers, body)
  146    151   
        } else {

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/query_precedence/_query_precedence_input.rs

@@ -22,22 +151,153 @@
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Map,
   44     44   
    "baz",
   45     45   
    1,
   46     46   
)
   47     47   
.with_http_query_params();
   48     48   
static QUERYPRECEDENCEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    QUERYPRECEDENCEINPUT_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[&QUERYPRECEDENCEINPUT_MEMBER_FOO, &QUERYPRECEDENCEINPUT_MEMBER_BAZ],
   52         -
);
          52  +
)
          53  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/Precedence", None));
   53     54   
impl QueryPrecedenceInput {
   54     55   
    /// The schema for this shape.
   55     56   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYPRECEDENCEINPUT_SCHEMA;
   56     57   
}
   57     58   
impl ::aws_smithy_schema::serde::SerializableStruct for QueryPrecedenceInput {
   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.foo {
   64     65   
            ser.write_string(&QUERYPRECEDENCEINPUT_MEMBER_FOO, val)?;
   65     66   
        }
   66     67   
        if let Some(ref val) = self.baz {
   67     68   
            ser.write_map(
   68     69   
                &QUERYPRECEDENCEINPUT_MEMBER_BAZ,
   69     70   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   70     71   
                    for (key, value) in val {
   71     72   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   72     73   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
   73     74   
                    }
   74     75   
                    Ok(())
   75     76   
                },
   76     77   
            )?;
   77     78   
        }
   78     79   
        Ok(())
   79     80   
    }
   80     81   
}
   81     82   
impl QueryPrecedenceInput {
   82     83   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   83         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   84         -
        deserializer: &mut D,
          84  +
    pub fn deserialize(
          85  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   85     86   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   86     87   
        #[allow(unused_variables, unused_mut)]
   87     88   
        let mut builder = Self::builder();
   88     89   
        #[allow(
   89     90   
            unused_variables,
   90     91   
            unreachable_code,
   91     92   
            clippy::single_match,
   92     93   
            clippy::match_single_binding,
   93     94   
            clippy::diverging_sub_expression
   94     95   
        )]
   95         -
        deserializer.read_struct(&QUERYPRECEDENCEINPUT_SCHEMA, (), |_, member, deser| {
          96  +
        deserializer.read_struct(&QUERYPRECEDENCEINPUT_SCHEMA, &mut |member, deser| {
   96     97   
            match member.member_index() {
   97     98   
                Some(0) => {
   98     99   
                    builder.foo = Some(deser.read_string(member)?);
   99    100   
                }
  100    101   
                Some(1) => {
  101         -
                    builder.baz = Some({
  102         -
                        let container = if let Some(cap) = deser.container_size() {
  103         -
                            std::collections::HashMap::with_capacity(cap)
  104         -
                        } else {
  105         -
                            std::collections::HashMap::new()
  106         -
                        };
  107         -
                        deser.read_map(member, container, |mut map, key, deser| {
  108         -
                            map.insert(key, deser.read_string(member)?);
  109         -
                            Ok(map)
  110         -
                        })?
  111         -
                    });
         102  +
                    builder.baz = Some(deser.read_string_string_map(member)?);
  112    103   
                }
  113    104   
                _ => {}
  114    105   
            }
  115    106   
            Ok(())
  116    107   
        })?;
  117    108   
        builder
  118    109   
            .build()
  119    110   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  120    111   
    }
  121    112   
}
         113  +
impl QueryPrecedenceInput {
         114  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         115  +
    pub fn deserialize_with_response(
         116  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         117  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         118  +
        _status: u16,
         119  +
        _body: &[u8],
         120  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         121  +
        Self::deserialize(deserializer)
         122  +
    }
         123  +
}
  122    124   
impl QueryPrecedenceInput {
  123    125   
    /// Creates a new builder-style object to manufacture [`QueryPrecedenceInput`](crate::operation::query_precedence::QueryPrecedenceInput).
  124    126   
    pub fn builder() -> crate::operation::query_precedence::builders::QueryPrecedenceInputBuilder {
  125    127   
        crate::operation::query_precedence::builders::QueryPrecedenceInputBuilder::default()
  126    128   
    }
  127    129   
}
  128    130   
  129    131   
/// A builder for [`QueryPrecedenceInput`](crate::operation::query_precedence::QueryPrecedenceInput).
  130    132   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  131    133   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/query_precedence/_query_precedence_output.rs

@@ -1,1 +65,76 @@
   18     18   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   19     19   
    fn serialize_members(
   20     20   
        &self,
   21     21   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   22     22   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   23     23   
        Ok(())
   24     24   
    }
   25     25   
}
   26     26   
impl QueryPrecedenceOutput {
   27     27   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   28         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   29         -
        deserializer: &mut D,
          28  +
    pub fn deserialize(
          29  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   30     30   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   31     31   
        #[allow(unused_variables, unused_mut)]
   32     32   
        let mut builder = Self::builder();
   33     33   
        #[allow(
   34     34   
            unused_variables,
   35     35   
            unreachable_code,
   36     36   
            clippy::single_match,
   37     37   
            clippy::match_single_binding,
   38     38   
            clippy::diverging_sub_expression
   39     39   
        )]
   40         -
        deserializer.read_struct(&QUERYPRECEDENCEOUTPUT_SCHEMA, (), |_, member, deser| {
          40  +
        deserializer.read_struct(&QUERYPRECEDENCEOUTPUT_SCHEMA, &mut |member, deser| {
   41     41   
            match member.member_index() {
   42     42   
                _ => {}
   43     43   
            }
   44     44   
            Ok(())
   45     45   
        })?;
   46     46   
        Ok(builder.build())
   47     47   
    }
   48     48   
}
          49  +
impl QueryPrecedenceOutput {
          50  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          51  +
    pub fn deserialize_with_response(
          52  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          53  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          54  +
        _status: u16,
          55  +
        _body: &[u8],
          56  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          57  +
        Ok(Self::builder().build())
          58  +
    }
          59  +
}
   49     60   
impl QueryPrecedenceOutput {
   50     61   
    /// Creates a new builder-style object to manufacture [`QueryPrecedenceOutput`](crate::operation::query_precedence::QueryPrecedenceOutput).
   51     62   
    pub fn builder() -> crate::operation::query_precedence::builders::QueryPrecedenceOutputBuilder {
   52     63   
        crate::operation::query_precedence::builders::QueryPrecedenceOutputBuilder::default()
   53     64   
    }
   54     65   
}
   55     66   
   56     67   
/// A builder for [`QueryPrecedenceOutput`](crate::operation::query_precedence::QueryPrecedenceOutput).
   57     68   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   58     69   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/recursive_shapes.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 `RecursiveShapes`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct RecursiveShapes;
    6      6   
impl RecursiveShapes {
    7      7   
    /// Creates a new `RecursiveShapes`
    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::recursive_shapes::RecursiveShapesInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::recursive_shapes::RecursiveShapesOutput::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::recursive_shapes::RecursiveShapesInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::recursive_shapes::RecursiveShapesOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::recursive_shapes::RecursiveShapesError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -104,108 +166,171 @@
  124    128   
                crate::operation::recursive_shapes::RecursiveShapesError,
  125    129   
            >::new());
  126    130   
  127    131   
        ::std::borrow::Cow::Owned(rcb)
  128    132   
    }
  129    133   
}
  130    134   
  131    135   
#[derive(Debug)]
  132    136   
struct RecursiveShapesResponseDeserializer;
  133    137   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RecursiveShapesResponseDeserializer {
  134         -
    fn deserialize_nonstreaming(
         138  +
    fn deserialize_nonstreaming_with_config(
  135    139   
        &self,
  136    140   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         141  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  137    142   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  138    143   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  139    144   
        let headers = response.headers();
  140    145   
        let body = response.body().bytes().expect("body loaded");
  141    146   
        #[allow(unused_mut)]
  142    147   
        let mut force_error = false;
  143    148   
  144    149   
        let parse_result = if !success && status != 200 || force_error {
  145    150   
            crate::protocol_serde::shape_recursive_shapes::de_recursive_shapes_http_error(status, headers, body)
  146    151   
        } else {
@@ -309,314 +369,378 @@
  329    334   
            .expect("the config must have a deserializer");
  330    335   
  331    336   
        let parsed = de.deserialize_streaming(&mut http_response);
  332    337   
        let parsed = parsed.unwrap_or_else(|| {
  333    338   
            let http_response = http_response.map(|body| {
  334    339   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  335    340   
                    body.bytes().unwrap(),
  336    341   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  337    342   
                )))
  338    343   
            });
  339         -
            de.deserialize_nonstreaming(&http_response)
         344  +
            // Build a config bag with the protocol for schema-based deserialization
         345  +
            #[allow(unused_mut)]
         346  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         347  +
         348  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  340    349   
        });
  341    350   
        let parsed = parsed
  342    351   
            .expect("should be successful response")
  343    352   
            .downcast::<crate::operation::recursive_shapes::RecursiveShapesOutput>()
  344    353   
            .unwrap();
  345    354   
        ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
  346    355   
    }
  347    356   
}
  348    357   
  349    358   
/// Error type for the `RecursiveShapesError` operation.

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/recursive_shapes/_recursive_shapes_input.rs

@@ -4,4 +108,120 @@
   24     24   
        "RecursiveShapesInput",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    "nested",
   28     28   
    0,
   29     29   
);
   30     30   
static RECURSIVESHAPESINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   31     31   
    RECURSIVESHAPESINPUT_SCHEMA_ID,
   32     32   
    ::aws_smithy_schema::ShapeType::Structure,
   33     33   
    &[&RECURSIVESHAPESINPUT_MEMBER_NESTED],
   34         -
);
          34  +
)
          35  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/RecursiveShapes", None));
   35     36   
impl RecursiveShapesInput {
   36     37   
    /// The schema for this shape.
   37     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RECURSIVESHAPESINPUT_SCHEMA;
   38     39   
}
   39     40   
impl ::aws_smithy_schema::serde::SerializableStruct for RecursiveShapesInput {
   40     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   41     42   
    fn serialize_members(
   42     43   
        &self,
   43     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   44     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   45     46   
        if let Some(ref val) = self.nested {
   46     47   
            ser.write_struct(&RECURSIVESHAPESINPUT_MEMBER_NESTED, val)?;
   47     48   
        }
   48     49   
        Ok(())
   49     50   
    }
   50     51   
}
   51     52   
impl RecursiveShapesInput {
   52     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   53         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   54         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   55     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   56     57   
        #[allow(unused_variables, unused_mut)]
   57     58   
        let mut builder = Self::builder();
   58     59   
        #[allow(
   59     60   
            unused_variables,
   60     61   
            unreachable_code,
   61     62   
            clippy::single_match,
   62     63   
            clippy::match_single_binding,
   63     64   
            clippy::diverging_sub_expression
   64     65   
        )]
   65         -
        deserializer.read_struct(&RECURSIVESHAPESINPUT_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&RECURSIVESHAPESINPUT_SCHEMA, &mut |member, deser| {
   66     67   
            match member.member_index() {
   67     68   
                Some(0) => {
   68     69   
                    builder.nested = Some(crate::types::RecursiveShapesInputOutputNested1::deserialize(deser)?);
   69     70   
                }
   70     71   
                _ => {}
   71     72   
            }
   72     73   
            Ok(())
   73     74   
        })?;
   74     75   
        builder
   75     76   
            .build()
   76     77   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   77     78   
    }
   78     79   
}
          80  +
impl RecursiveShapesInput {
          81  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          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  +
        Self::deserialize(deserializer)
          89  +
    }
          90  +
}
   79     91   
impl RecursiveShapesInput {
   80     92   
    /// Creates a new builder-style object to manufacture [`RecursiveShapesInput`](crate::operation::recursive_shapes::RecursiveShapesInput).
   81     93   
    pub fn builder() -> crate::operation::recursive_shapes::builders::RecursiveShapesInputBuilder {
   82     94   
        crate::operation::recursive_shapes::builders::RecursiveShapesInputBuilder::default()
   83     95   
    }
   84     96   
}
   85     97   
   86     98   
/// A builder for [`RecursiveShapesInput`](crate::operation::recursive_shapes::RecursiveShapesInput).
   87     99   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88    100   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/recursive_shapes/_recursive_shapes_output.rs

@@ -23,23 +106,117 @@
   43     43   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   44     44   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   45     45   
        if let Some(ref val) = self.nested {
   46     46   
            ser.write_struct(&RECURSIVESHAPESOUTPUT_MEMBER_NESTED, val)?;
   47     47   
        }
   48     48   
        Ok(())
   49     49   
    }
   50     50   
}
   51     51   
impl RecursiveShapesOutput {
   52     52   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   53         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   54         -
        deserializer: &mut D,
          53  +
    pub fn deserialize(
          54  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   55     55   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   56     56   
        #[allow(unused_variables, unused_mut)]
   57     57   
        let mut builder = Self::builder();
   58     58   
        #[allow(
   59     59   
            unused_variables,
   60     60   
            unreachable_code,
   61     61   
            clippy::single_match,
   62     62   
            clippy::match_single_binding,
   63     63   
            clippy::diverging_sub_expression
   64     64   
        )]
   65         -
        deserializer.read_struct(&RECURSIVESHAPESOUTPUT_SCHEMA, (), |_, member, deser| {
          65  +
        deserializer.read_struct(&RECURSIVESHAPESOUTPUT_SCHEMA, &mut |member, deser| {
   66     66   
            match member.member_index() {
   67     67   
                Some(0) => {
   68     68   
                    builder.nested = Some(crate::types::RecursiveShapesInputOutputNested1::deserialize(deser)?);
   69     69   
                }
   70     70   
                _ => {}
   71     71   
            }
   72     72   
            Ok(())
   73     73   
        })?;
   74     74   
        Ok(builder.build())
   75     75   
    }
   76     76   
}
          77  +
impl RecursiveShapesOutput {
          78  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          79  +
    pub fn deserialize_with_response(
          80  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          81  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          82  +
        _status: u16,
          83  +
        _body: &[u8],
          84  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          85  +
        Self::deserialize(deserializer)
          86  +
    }
          87  +
}
   77     88   
impl RecursiveShapesOutput {
   78     89   
    /// Creates a new builder-style object to manufacture [`RecursiveShapesOutput`](crate::operation::recursive_shapes::RecursiveShapesOutput).
   79     90   
    pub fn builder() -> crate::operation::recursive_shapes::builders::RecursiveShapesOutputBuilder {
   80     91   
        crate::operation::recursive_shapes::builders::RecursiveShapesOutputBuilder::default()
   81     92   
    }
   82     93   
}
   83     94   
   84     95   
/// A builder for [`RecursiveShapesOutput`](crate::operation::recursive_shapes::RecursiveShapesOutput).
   85     96   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   86     97   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/simple_scalar_properties.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 `SimpleScalarProperties`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct SimpleScalarProperties;
    6      6   
impl SimpleScalarProperties {
    7      7   
    /// Creates a new `SimpleScalarProperties`
    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::simple_scalar_properties::SimpleScalarPropertiesInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::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::simple_scalar_properties::SimpleScalarPropertiesInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::simple_scalar_properties::SimpleScalarPropertiesError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -110,114 +172,177 @@
  130    134   
                crate::operation::simple_scalar_properties::SimpleScalarPropertiesError,
  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 SimpleScalarPropertiesResponseDeserializer;
  139    143   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for SimpleScalarPropertiesResponseDeserializer {
  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());
  145    150   
        let headers = response.headers();
  146    151   
        let body = response.body().bytes().expect("body loaded");
  147    152   
        #[allow(unused_mut)]
  148    153   
        let mut force_error = false;
  149    154   
  150    155   
        let parse_result = if !success && status != 200 || force_error {
  151    156   
            crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_http_error(status, headers, body)
  152    157   
        } else {
@@ -516,521 +576,585 @@
  536    541   
            .expect("the config must have a deserializer");
  537    542   
  538    543   
        let parsed = de.deserialize_streaming(&mut http_response);
  539    544   
        let parsed = parsed.unwrap_or_else(|| {
  540    545   
            let http_response = http_response.map(|body| {
  541    546   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  542    547   
                    body.bytes().unwrap(),
  543    548   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  544    549   
                )))
  545    550   
            });
  546         -
            de.deserialize_nonstreaming(&http_response)
         551  +
            // Build a config bag with the protocol for schema-based deserialization
         552  +
            #[allow(unused_mut)]
         553  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         554  +
         555  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  547    556   
        });
  548    557   
        let parsed = parsed
  549    558   
            .expect("should be successful response")
  550    559   
            .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
  551    560   
            .unwrap();
  552    561   
        ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
  553    562   
        ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
  554    563   
        ::pretty_assertions::assert_eq!(
  555    564   
            parsed.true_boolean_value,
  556    565   
            expected_output.true_boolean_value,
@@ -595,604 +655,668 @@
  615    624   
            .expect("the config must have a deserializer");
  616    625   
  617    626   
        let parsed = de.deserialize_streaming(&mut http_response);
  618    627   
        let parsed = parsed.unwrap_or_else(|| {
  619    628   
            let http_response = http_response.map(|body| {
  620    629   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  621    630   
                    body.bytes().unwrap(),
  622    631   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  623    632   
                )))
  624    633   
            });
  625         -
            de.deserialize_nonstreaming(&http_response)
         634  +
            // Build a config bag with the protocol for schema-based deserialization
         635  +
            #[allow(unused_mut)]
         636  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         637  +
         638  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  626    639   
        });
  627    640   
        let parsed = parsed
  628    641   
            .expect("should be successful response")
  629    642   
            .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
  630    643   
            .unwrap();
  631    644   
        ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
  632    645   
        ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
  633    646   
        ::pretty_assertions::assert_eq!(
  634    647   
            parsed.true_boolean_value,
  635    648   
            expected_output.true_boolean_value,
@@ -672,685 +732,749 @@
  692    705   
            .expect("the config must have a deserializer");
  693    706   
  694    707   
        let parsed = de.deserialize_streaming(&mut http_response);
  695    708   
        let parsed = parsed.unwrap_or_else(|| {
  696    709   
            let http_response = http_response.map(|body| {
  697    710   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  698    711   
                    body.bytes().unwrap(),
  699    712   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  700    713   
                )))
  701    714   
            });
  702         -
            de.deserialize_nonstreaming(&http_response)
         715  +
            // Build a config bag with the protocol for schema-based deserialization
         716  +
            #[allow(unused_mut)]
         717  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         718  +
         719  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  703    720   
        });
  704    721   
        let parsed = parsed
  705    722   
            .expect("should be successful response")
  706    723   
            .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
  707    724   
            .unwrap();
  708    725   
        ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
  709    726   
        ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
  710    727   
        ::pretty_assertions::assert_eq!(
  711    728   
            parsed.true_boolean_value,
  712    729   
            expected_output.true_boolean_value,
@@ -745,762 +805,826 @@
  765    782   
            .expect("the config must have a deserializer");
  766    783   
  767    784   
        let parsed = de.deserialize_streaming(&mut http_response);
  768    785   
        let parsed = parsed.unwrap_or_else(|| {
  769    786   
            let http_response = http_response.map(|body| {
  770    787   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  771    788   
                    body.bytes().unwrap(),
  772    789   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  773    790   
                )))
  774    791   
            });
  775         -
            de.deserialize_nonstreaming(&http_response)
         792  +
            // Build a config bag with the protocol for schema-based deserialization
         793  +
            #[allow(unused_mut)]
         794  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         795  +
         796  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  776    797   
        });
  777    798   
        let parsed = parsed
  778    799   
            .expect("should be successful response")
  779    800   
            .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
  780    801   
            .unwrap();
  781    802   
        ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
  782    803   
        ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
  783    804   
        ::pretty_assertions::assert_eq!(
  784    805   
            parsed.true_boolean_value,
  785    806   
            expected_output.true_boolean_value,
@@ -818,839 +878,903 @@
  838    859   
            .expect("the config must have a deserializer");
  839    860   
  840    861   
        let parsed = de.deserialize_streaming(&mut http_response);
  841    862   
        let parsed = parsed.unwrap_or_else(|| {
  842    863   
            let http_response = http_response.map(|body| {
  843    864   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  844    865   
                    body.bytes().unwrap(),
  845    866   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  846    867   
                )))
  847    868   
            });
  848         -
            de.deserialize_nonstreaming(&http_response)
         869  +
            // Build a config bag with the protocol for schema-based deserialization
         870  +
            #[allow(unused_mut)]
         871  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         872  +
         873  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  849    874   
        });
  850    875   
        let parsed = parsed
  851    876   
            .expect("should be successful response")
  852    877   
            .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
  853    878   
            .unwrap();
  854    879   
        ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
  855    880   
        ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
  856    881   
        ::pretty_assertions::assert_eq!(
  857    882   
            parsed.true_boolean_value,
  858    883   
            expected_output.true_boolean_value,
@@ -891,916 +951,980 @@
  911    936   
            .expect("the config must have a deserializer");
  912    937   
  913    938   
        let parsed = de.deserialize_streaming(&mut http_response);
  914    939   
        let parsed = parsed.unwrap_or_else(|| {
  915    940   
            let http_response = http_response.map(|body| {
  916    941   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  917    942   
                    body.bytes().unwrap(),
  918    943   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  919    944   
                )))
  920    945   
            });
  921         -
            de.deserialize_nonstreaming(&http_response)
         946  +
            // Build a config bag with the protocol for schema-based deserialization
         947  +
            #[allow(unused_mut)]
         948  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         949  +
         950  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  922    951   
        });
  923    952   
        let parsed = parsed
  924    953   
            .expect("should be successful response")
  925    954   
            .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
  926    955   
            .unwrap();
  927    956   
        ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
  928    957   
        ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
  929    958   
        ::pretty_assertions::assert_eq!(
  930    959   
            parsed.true_boolean_value,
  931    960   
            expected_output.true_boolean_value,
@@ -967,996 +1027,1060 @@
  987   1016   
            .expect("the config must have a deserializer");
  988   1017   
  989   1018   
        let parsed = de.deserialize_streaming(&mut http_response);
  990   1019   
        let parsed = parsed.unwrap_or_else(|| {
  991   1020   
            let http_response = http_response.map(|body| {
  992   1021   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  993   1022   
                    body.bytes().unwrap(),
  994   1023   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  995   1024   
                )))
  996   1025   
            });
  997         -
            de.deserialize_nonstreaming(&http_response)
        1026  +
            // Build a config bag with the protocol for schema-based deserialization
        1027  +
            #[allow(unused_mut)]
        1028  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
        1029  +
        1030  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  998   1031   
        });
  999   1032   
        let parsed = parsed
 1000   1033   
            .expect("should be successful response")
 1001   1034   
            .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
 1002   1035   
            .unwrap();
 1003   1036   
        ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
 1004   1037   
        ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
 1005   1038   
        ::pretty_assertions::assert_eq!(
 1006   1039   
            parsed.true_boolean_value,
 1007   1040   
            expected_output.true_boolean_value,
@@ -1043,1076 +1103,1140 @@
 1063   1096   
            .expect("the config must have a deserializer");
 1064   1097   
 1065   1098   
        let parsed = de.deserialize_streaming(&mut http_response);
 1066   1099   
        let parsed = parsed.unwrap_or_else(|| {
 1067   1100   
            let http_response = http_response.map(|body| {
 1068   1101   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 1069   1102   
                    body.bytes().unwrap(),
 1070   1103   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
 1071   1104   
                )))
 1072   1105   
            });
 1073         -
            de.deserialize_nonstreaming(&http_response)
        1106  +
            // Build a config bag with the protocol for schema-based deserialization
        1107  +
            #[allow(unused_mut)]
        1108  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
        1109  +
        1110  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
 1074   1111   
        });
 1075   1112   
        let parsed = parsed
 1076   1113   
            .expect("should be successful response")
 1077   1114   
            .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
 1078   1115   
            .unwrap();
 1079   1116   
        ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
 1080   1117   
        ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
 1081   1118   
        ::pretty_assertions::assert_eq!(
 1082   1119   
            parsed.true_boolean_value,
 1083   1120   
            expected_output.true_boolean_value,
@@ -1119,1156 +1179,1220 @@
 1139   1176   
            .expect("the config must have a deserializer");
 1140   1177   
 1141   1178   
        let parsed = de.deserialize_streaming(&mut http_response);
 1142   1179   
        let parsed = parsed.unwrap_or_else(|| {
 1143   1180   
            let http_response = http_response.map(|body| {
 1144   1181   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 1145   1182   
                    body.bytes().unwrap(),
 1146   1183   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
 1147   1184   
                )))
 1148   1185   
            });
 1149         -
            de.deserialize_nonstreaming(&http_response)
        1186  +
            // Build a config bag with the protocol for schema-based deserialization
        1187  +
            #[allow(unused_mut)]
        1188  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
        1189  +
        1190  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
 1150   1191   
        });
 1151   1192   
        let parsed = parsed
 1152   1193   
            .expect("should be successful response")
 1153   1194   
            .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
 1154   1195   
            .unwrap();
 1155   1196   
        ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
 1156   1197   
        ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
 1157   1198   
        ::pretty_assertions::assert_eq!(
 1158   1199   
            parsed.true_boolean_value,
 1159   1200   
            expected_output.true_boolean_value,

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/simple_scalar_properties/_simple_scalar_properties_input.rs

@@ -62,62 +319,381 @@
   82     82   
    0,
   83     83   
)
   84     84   
.with_http_header("X-Foo");
   85     85   
static SIMPLESCALARPROPERTIESINPUT_MEMBER_STRING_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "aws.protocoltests.restxml.synthetic#SimpleScalarPropertiesInput$stringValue",
   88     88   
        "aws.protocoltests.restxml.synthetic",
   89     89   
        "SimpleScalarPropertiesInput",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::String,
   92         -
    "string_value",
          92  +
    "stringValue",
   93     93   
    1,
   94     94   
);
   95     95   
static SIMPLESCALARPROPERTIESINPUT_MEMBER_TRUE_BOOLEAN_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "aws.protocoltests.restxml.synthetic#SimpleScalarPropertiesInput$trueBooleanValue",
   98     98   
        "aws.protocoltests.restxml.synthetic",
   99     99   
        "SimpleScalarPropertiesInput",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::Boolean,
  102         -
    "true_boolean_value",
         102  +
    "trueBooleanValue",
  103    103   
    2,
  104    104   
);
  105    105   
static SIMPLESCALARPROPERTIESINPUT_MEMBER_FALSE_BOOLEAN_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static(
  107    107   
        "aws.protocoltests.restxml.synthetic#SimpleScalarPropertiesInput$falseBooleanValue",
  108    108   
        "aws.protocoltests.restxml.synthetic",
  109    109   
        "SimpleScalarPropertiesInput",
  110    110   
    ),
  111    111   
    ::aws_smithy_schema::ShapeType::Boolean,
  112         -
    "false_boolean_value",
         112  +
    "falseBooleanValue",
  113    113   
    3,
  114    114   
);
  115    115   
static SIMPLESCALARPROPERTIESINPUT_MEMBER_BYTE_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static(
  117    117   
        "aws.protocoltests.restxml.synthetic#SimpleScalarPropertiesInput$byteValue",
  118    118   
        "aws.protocoltests.restxml.synthetic",
  119    119   
        "SimpleScalarPropertiesInput",
  120    120   
    ),
  121    121   
    ::aws_smithy_schema::ShapeType::Byte,
  122         -
    "byte_value",
         122  +
    "byteValue",
  123    123   
    4,
  124    124   
);
  125    125   
static SIMPLESCALARPROPERTIESINPUT_MEMBER_SHORT_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "aws.protocoltests.restxml.synthetic#SimpleScalarPropertiesInput$shortValue",
  128    128   
        "aws.protocoltests.restxml.synthetic",
  129    129   
        "SimpleScalarPropertiesInput",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::Short,
  132         -
    "short_value",
         132  +
    "shortValue",
  133    133   
    5,
  134    134   
);
  135    135   
static SIMPLESCALARPROPERTIESINPUT_MEMBER_INTEGER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static(
  137    137   
        "aws.protocoltests.restxml.synthetic#SimpleScalarPropertiesInput$integerValue",
  138    138   
        "aws.protocoltests.restxml.synthetic",
  139    139   
        "SimpleScalarPropertiesInput",
  140    140   
    ),
  141    141   
    ::aws_smithy_schema::ShapeType::Integer,
  142         -
    "integer_value",
         142  +
    "integerValue",
  143    143   
    6,
  144    144   
);
  145    145   
static SIMPLESCALARPROPERTIESINPUT_MEMBER_LONG_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static(
  147    147   
        "aws.protocoltests.restxml.synthetic#SimpleScalarPropertiesInput$longValue",
  148    148   
        "aws.protocoltests.restxml.synthetic",
  149    149   
        "SimpleScalarPropertiesInput",
  150    150   
    ),
  151    151   
    ::aws_smithy_schema::ShapeType::Long,
  152         -
    "long_value",
         152  +
    "longValue",
  153    153   
    7,
  154    154   
);
  155    155   
static SIMPLESCALARPROPERTIESINPUT_MEMBER_FLOAT_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  156    156   
    ::aws_smithy_schema::ShapeId::from_static(
  157    157   
        "aws.protocoltests.restxml.synthetic#SimpleScalarPropertiesInput$floatValue",
  158    158   
        "aws.protocoltests.restxml.synthetic",
  159    159   
        "SimpleScalarPropertiesInput",
  160    160   
    ),
  161    161   
    ::aws_smithy_schema::ShapeType::Float,
  162         -
    "float_value",
         162  +
    "floatValue",
  163    163   
    8,
  164    164   
);
  165    165   
static SIMPLESCALARPROPERTIESINPUT_MEMBER_DOUBLE_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  166    166   
    ::aws_smithy_schema::ShapeId::from_static(
  167    167   
        "aws.protocoltests.restxml.synthetic#SimpleScalarPropertiesInput$doubleValue",
  168    168   
        "aws.protocoltests.restxml.synthetic",
  169    169   
        "SimpleScalarPropertiesInput",
  170    170   
    ),
  171    171   
    ::aws_smithy_schema::ShapeType::Double,
  172         -
    "double_value",
         172  +
    "doubleValue",
  173    173   
    9,
  174    174   
)
  175    175   
.with_xml_name("DoubleDribble");
  176    176   
static SIMPLESCALARPROPERTIESINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  177    177   
    SIMPLESCALARPROPERTIESINPUT_SCHEMA_ID,
  178    178   
    ::aws_smithy_schema::ShapeType::Structure,
  179    179   
    &[
  180    180   
        &SIMPLESCALARPROPERTIESINPUT_MEMBER_FOO,
  181    181   
        &SIMPLESCALARPROPERTIESINPUT_MEMBER_STRING_VALUE,
  182    182   
        &SIMPLESCALARPROPERTIESINPUT_MEMBER_TRUE_BOOLEAN_VALUE,
  183    183   
        &SIMPLESCALARPROPERTIESINPUT_MEMBER_FALSE_BOOLEAN_VALUE,
  184    184   
        &SIMPLESCALARPROPERTIESINPUT_MEMBER_BYTE_VALUE,
  185    185   
        &SIMPLESCALARPROPERTIESINPUT_MEMBER_SHORT_VALUE,
  186    186   
        &SIMPLESCALARPROPERTIESINPUT_MEMBER_INTEGER_VALUE,
  187    187   
        &SIMPLESCALARPROPERTIESINPUT_MEMBER_LONG_VALUE,
  188    188   
        &SIMPLESCALARPROPERTIESINPUT_MEMBER_FLOAT_VALUE,
  189    189   
        &SIMPLESCALARPROPERTIESINPUT_MEMBER_DOUBLE_VALUE,
  190    190   
    ],
  191         -
);
         191  +
)
         192  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/SimpleScalarProperties", None));
  192    193   
impl SimpleScalarPropertiesInput {
  193    194   
    /// The schema for this shape.
  194    195   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SIMPLESCALARPROPERTIESINPUT_SCHEMA;
  195    196   
}
  196    197   
impl ::aws_smithy_schema::serde::SerializableStruct for SimpleScalarPropertiesInput {
  197    198   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  198    199   
    fn serialize_members(
  199    200   
        &self,
  200    201   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  201    202   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  202    203   
        if let Some(ref val) = self.foo {
  203    204   
            ser.write_string(&SIMPLESCALARPROPERTIESINPUT_MEMBER_FOO, val)?;
  204    205   
        }
  205    206   
        if let Some(ref val) = self.string_value {
  206    207   
            ser.write_string(&SIMPLESCALARPROPERTIESINPUT_MEMBER_STRING_VALUE, val)?;
  207    208   
        }
  208    209   
        if let Some(ref val) = self.true_boolean_value {
  209    210   
            ser.write_boolean(&SIMPLESCALARPROPERTIESINPUT_MEMBER_TRUE_BOOLEAN_VALUE, *val)?;
  210    211   
        }
  211    212   
        if let Some(ref val) = self.false_boolean_value {
  212    213   
            ser.write_boolean(&SIMPLESCALARPROPERTIESINPUT_MEMBER_FALSE_BOOLEAN_VALUE, *val)?;
  213    214   
        }
  214    215   
        if let Some(ref val) = self.byte_value {
  215    216   
            ser.write_byte(&SIMPLESCALARPROPERTIESINPUT_MEMBER_BYTE_VALUE, *val)?;
  216    217   
        }
  217    218   
        if let Some(ref val) = self.short_value {
  218    219   
            ser.write_short(&SIMPLESCALARPROPERTIESINPUT_MEMBER_SHORT_VALUE, *val)?;
  219    220   
        }
  220    221   
        if let Some(ref val) = self.integer_value {
  221    222   
            ser.write_integer(&SIMPLESCALARPROPERTIESINPUT_MEMBER_INTEGER_VALUE, *val)?;
  222    223   
        }
  223    224   
        if let Some(ref val) = self.long_value {
  224    225   
            ser.write_long(&SIMPLESCALARPROPERTIESINPUT_MEMBER_LONG_VALUE, *val)?;
  225    226   
        }
  226    227   
        if let Some(ref val) = self.float_value {
  227    228   
            ser.write_float(&SIMPLESCALARPROPERTIESINPUT_MEMBER_FLOAT_VALUE, *val)?;
  228    229   
        }
  229    230   
        if let Some(ref val) = self.double_value {
  230    231   
            ser.write_double(&SIMPLESCALARPROPERTIESINPUT_MEMBER_DOUBLE_VALUE, *val)?;
  231    232   
        }
  232    233   
        Ok(())
  233    234   
    }
  234    235   
}
  235    236   
impl SimpleScalarPropertiesInput {
  236    237   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  237         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  238         -
        deserializer: &mut D,
         238  +
    pub fn deserialize(
         239  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  239    240   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  240    241   
        #[allow(unused_variables, unused_mut)]
  241    242   
        let mut builder = Self::builder();
  242    243   
        #[allow(
  243    244   
            unused_variables,
  244    245   
            unreachable_code,
  245    246   
            clippy::single_match,
  246    247   
            clippy::match_single_binding,
  247    248   
            clippy::diverging_sub_expression
  248    249   
        )]
  249         -
        deserializer.read_struct(&SIMPLESCALARPROPERTIESINPUT_SCHEMA, (), |_, member, deser| {
         250  +
        deserializer.read_struct(&SIMPLESCALARPROPERTIESINPUT_SCHEMA, &mut |member, deser| {
  250    251   
            match member.member_index() {
  251    252   
                Some(0) => {
  252    253   
                    builder.foo = Some(deser.read_string(member)?);
  253    254   
                }
  254    255   
                Some(1) => {
  255    256   
                    builder.string_value = Some(deser.read_string(member)?);
  256    257   
                }
  257    258   
                Some(2) => {
  258    259   
                    builder.true_boolean_value = Some(deser.read_boolean(member)?);
  259    260   
                }
  260    261   
                Some(3) => {
  261    262   
                    builder.false_boolean_value = Some(deser.read_boolean(member)?);
  262    263   
                }
  263    264   
                Some(4) => {
  264    265   
                    builder.byte_value = Some(deser.read_byte(member)?);
  265    266   
                }
  266    267   
                Some(5) => {
  267    268   
                    builder.short_value = Some(deser.read_short(member)?);
  268    269   
                }
  269    270   
                Some(6) => {
  270    271   
                    builder.integer_value = Some(deser.read_integer(member)?);
  271    272   
                }
  272    273   
                Some(7) => {
  273    274   
                    builder.long_value = Some(deser.read_long(member)?);
  274    275   
                }
  275    276   
                Some(8) => {
  276    277   
                    builder.float_value = Some(deser.read_float(member)?);
  277    278   
                }
  278    279   
                Some(9) => {
  279    280   
                    builder.double_value = Some(deser.read_double(member)?);
  280    281   
                }
  281    282   
                _ => {}
  282    283   
            }
  283    284   
            Ok(())
  284    285   
        })?;
  285    286   
        builder
  286    287   
            .build()
  287    288   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  288    289   
    }
  289    290   
}
         291  +
impl SimpleScalarPropertiesInput {
         292  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         293  +
    /// Header-bound members are read directly from headers, avoiding runtime
         294  +
    /// member iteration overhead. Body members are read via the deserializer.
         295  +
    pub fn deserialize_with_response(
         296  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         297  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         298  +
        _status: u16,
         299  +
        _body: &[u8],
         300  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         301  +
        #[allow(unused_variables, unused_mut)]
         302  +
        let mut builder = Self::builder();
         303  +
        if let Some(val) = headers.get("X-Foo") {
         304  +
            builder.foo = Some(val.to_string());
         305  +
        }
         306  +
        #[allow(
         307  +
            unused_variables,
         308  +
            unreachable_code,
         309  +
            clippy::single_match,
         310  +
            clippy::match_single_binding,
         311  +
            clippy::diverging_sub_expression
         312  +
        )]
         313  +
        deserializer.read_struct(&SIMPLESCALARPROPERTIESINPUT_SCHEMA, &mut |member, deser| {
         314  +
            match member.member_index() {
         315  +
                Some(0) => { /* read from headers above */ }
         316  +
                Some(1) => {
         317  +
                    builder.string_value = Some(deser.read_string(member)?);
         318  +
                }
         319  +
                Some(2) => {
         320  +
                    builder.true_boolean_value = Some(deser.read_boolean(member)?);
         321  +
                }
         322  +
                Some(3) => {
         323  +
                    builder.false_boolean_value = Some(deser.read_boolean(member)?);
         324  +
                }
         325  +
                Some(4) => {
         326  +
                    builder.byte_value = Some(deser.read_byte(member)?);
         327  +
                }
         328  +
                Some(5) => {
         329  +
                    builder.short_value = Some(deser.read_short(member)?);
         330  +
                }
         331  +
                Some(6) => {
         332  +
                    builder.integer_value = Some(deser.read_integer(member)?);
         333  +
                }
         334  +
                Some(7) => {
         335  +
                    builder.long_value = Some(deser.read_long(member)?);
         336  +
                }
         337  +
                Some(8) => {
         338  +
                    builder.float_value = Some(deser.read_float(member)?);
         339  +
                }
         340  +
                Some(9) => {
         341  +
                    builder.double_value = Some(deser.read_double(member)?);
         342  +
                }
         343  +
                _ => {}
         344  +
            }
         345  +
            Ok(())
         346  +
        })?;
         347  +
        builder
         348  +
            .build()
         349  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         350  +
    }
         351  +
}
  290    352   
impl SimpleScalarPropertiesInput {
  291    353   
    /// Creates a new builder-style object to manufacture [`SimpleScalarPropertiesInput`](crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput).
  292    354   
    pub fn builder() -> crate::operation::simple_scalar_properties::builders::SimpleScalarPropertiesInputBuilder {
  293    355   
        crate::operation::simple_scalar_properties::builders::SimpleScalarPropertiesInputBuilder::default()
  294    356   
    }
  295    357   
}
  296    358   
  297    359   
/// A builder for [`SimpleScalarPropertiesInput`](crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput).
  298    360   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  299    361   
#[non_exhaustive]