AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406

Files changed:

tmp-codegen-diff/aws-sdk/sdk/polly/src/types/error/_ssml_marks_not_supported_for_text_type_exception.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&SSMLMARKSNOTSUPPORTEDFORTEXTTYPEEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl SsmlMarksNotSupportedForTextTypeException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&SSMLMARKSNOTSUPPORTEDFORTEXTTYPEEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&SSMLMARKSNOTSUPPORTEDFORTEXTTYPEEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl SsmlMarksNotSupportedForTextTypeException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl SsmlMarksNotSupportedForTextTypeException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for SsmlMarksNotSupportedForTextTypeException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "SsmlMarksNotSupportedForTextTypeException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/polly/src/types/error/_synthesis_task_not_found_exception.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&SYNTHESISTASKNOTFOUNDEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl SynthesisTaskNotFoundException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&SYNTHESISTASKNOTFOUNDEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&SYNTHESISTASKNOTFOUNDEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl SynthesisTaskNotFoundException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl SynthesisTaskNotFoundException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for SynthesisTaskNotFoundException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "SynthesisTaskNotFoundException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/polly/src/types/error/_text_length_exceeded_exception.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&TEXTLENGTHEXCEEDEDEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl TextLengthExceededException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&TEXTLENGTHEXCEEDEDEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&TEXTLENGTHEXCEEDEDEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl TextLengthExceededException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl TextLengthExceededException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for TextLengthExceededException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "TextLengthExceededException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/polly/src/types/error/_unsupported_pls_alphabet_exception.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&UNSUPPORTEDPLSALPHABETEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl UnsupportedPlsAlphabetException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&UNSUPPORTEDPLSALPHABETEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&UNSUPPORTEDPLSALPHABETEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl UnsupportedPlsAlphabetException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl UnsupportedPlsAlphabetException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for UnsupportedPlsAlphabetException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "UnsupportedPlsAlphabetException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/polly/src/types/error/_unsupported_pls_language_exception.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&UNSUPPORTEDPLSLANGUAGEEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl UnsupportedPlsLanguageException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&UNSUPPORTEDPLSLANGUAGEEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&UNSUPPORTEDPLSLANGUAGEEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl UnsupportedPlsLanguageException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl UnsupportedPlsLanguageException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for UnsupportedPlsLanguageException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "UnsupportedPlsLanguageException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/route53/Cargo.toml

@@ -1,1 +80,80 @@
   14     14   
protocol = "aws.protocols#restXml"
   15     15   
[package.metadata.docs.rs]
   16     16   
all-features = true
   17     17   
targets = ["x86_64-unknown-linux-gnu"]
   18     18   
[dependencies.aws-credential-types]
   19     19   
path = "../aws-credential-types"
   20     20   
version = "1.2.14"
   21     21   
   22     22   
[dependencies.aws-runtime]
   23     23   
path = "../aws-runtime"
   24         -
version = "1.7.3"
          24  +
version = "1.7.4"
   25     25   
   26     26   
[dependencies.aws-smithy-async]
   27     27   
path = "../aws-smithy-async"
   28     28   
version = "1.2.14"
   29     29   
   30     30   
[dependencies.aws-smithy-http]
   31     31   
path = "../aws-smithy-http"
   32     32   
version = "0.63.6"
   33     33   
   34     34   
[dependencies.aws-smithy-json]
   35     35   
path = "../aws-smithy-json"
   36     36   
version = "0.62.6"
   37     37   
   38     38   
[dependencies.aws-smithy-observability]
   39     39   
path = "../aws-smithy-observability"
   40     40   
version = "0.2.6"
   41     41   
   42     42   
[dependencies.aws-smithy-runtime]
   43     43   
path = "../aws-smithy-runtime"
   44     44   
features = ["client"]
   45         -
version = "1.10.3"
          45  +
version = "1.10.4"
   46     46   
   47     47   
[dependencies.aws-smithy-runtime-api]
   48     48   
path = "../aws-smithy-runtime-api"
   49     49   
features = ["client", "http-1x"]
   50         -
version = "1.11.6"
          50  +
version = "1.11.7"
   51     51   
   52     52   
[dependencies.aws-smithy-schema]
   53     53   
path = "../aws-smithy-schema"
   54     54   
version = "1.0.0"
   55     55   
   56     56   
[dependencies.aws-smithy-types]
   57     57   
path = "../aws-smithy-types"
   58     58   
features = ["http-body-1-x"]
   59     59   
version = "1.4.7"
   60     60

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/activate_key_signing_key.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 `ActivateKeySigningKey`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ActivateKeySigningKey;
    6      6   
impl ActivateKeySigningKey {
    7      7   
    /// Creates a new `ActivateKeySigningKey`
    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::activate_key_signing_key::ActivateKeySigningKeyInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::activate_key_signing_key::ActivateKeySigningKeyOutput::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::activate_key_signing_key::ActivateKeySigningKeyInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::activate_key_signing_key::ActivateKeySigningKeyOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::activate_key_signing_key::ActivateKeySigningKeyError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -121,125 +183,188 @@
  141    145   
                crate::operation::activate_key_signing_key::ActivateKeySigningKeyError,
  142    146   
            >::new());
  143    147   
  144    148   
        ::std::borrow::Cow::Owned(rcb)
  145    149   
    }
  146    150   
}
  147    151   
  148    152   
#[derive(Debug)]
  149    153   
struct ActivateKeySigningKeyResponseDeserializer;
  150    154   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ActivateKeySigningKeyResponseDeserializer {
  151         -
    fn deserialize_nonstreaming(
         155  +
    fn deserialize_nonstreaming_with_config(
  152    156   
        &self,
  153    157   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         158  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  154    159   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  155    160   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  156    161   
        let headers = response.headers();
  157    162   
        let body = response.body().bytes().expect("body loaded");
  158    163   
        #[allow(unused_mut)]
  159    164   
        let mut force_error = false;
  160    165   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  161    166   
        let parse_result = if !success && status != 200 || force_error {
  162    167   
            crate::protocol_serde::shape_activate_key_signing_key::de_activate_key_signing_key_http_error(status, headers, body)
  163    168   
        } else {

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/activate_key_signing_key/_activate_key_signing_key_input.rs

@@ -3,3 +132,150 @@
   23     23   
    "com.amazonaws.route53.synthetic",
   24     24   
    "ActivateKeySigningKeyInput",
   25     25   
);
   26     26   
static ACTIVATEKEYSIGNINGKEYINPUT_MEMBER_HOSTED_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static(
   28     28   
        "com.amazonaws.route53.synthetic#ActivateKeySigningKeyInput$HostedZoneId",
   29     29   
        "com.amazonaws.route53.synthetic",
   30     30   
        "ActivateKeySigningKeyInput",
   31     31   
    ),
   32     32   
    ::aws_smithy_schema::ShapeType::String,
   33         -
    "hosted_zone_id",
          33  +
    "HostedZoneId",
   34     34   
    0,
   35     35   
)
   36     36   
.with_http_label();
   37     37   
static ACTIVATEKEYSIGNINGKEYINPUT_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.route53.synthetic#ActivateKeySigningKeyInput$Name",
   40     40   
        "com.amazonaws.route53.synthetic",
   41     41   
        "ActivateKeySigningKeyInput",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::String,
   44         -
    "name",
          44  +
    "Name",
   45     45   
    1,
   46     46   
)
   47     47   
.with_http_label();
   48     48   
static ACTIVATEKEYSIGNINGKEYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    ACTIVATEKEYSIGNINGKEYINPUT_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[&ACTIVATEKEYSIGNINGKEYINPUT_MEMBER_HOSTED_ZONE_ID, &ACTIVATEKEYSIGNINGKEYINPUT_MEMBER_NAME],
   52         -
);
          52  +
)
          53  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
          54  +
    "POST",
          55  +
    "/2013-04-01/keysigningkey/{HostedZoneId}/{Name}/activate",
          56  +
    None,
          57  +
));
   53     58   
impl ActivateKeySigningKeyInput {
   54     59   
    /// The schema for this shape.
   55     60   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ACTIVATEKEYSIGNINGKEYINPUT_SCHEMA;
   56     61   
}
   57     62   
impl ::aws_smithy_schema::serde::SerializableStruct for ActivateKeySigningKeyInput {
   58     63   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   59     64   
    fn serialize_members(
   60     65   
        &self,
   61     66   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   62     67   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   63     68   
        if let Some(ref val) = self.hosted_zone_id {
   64     69   
            ser.write_string(&ACTIVATEKEYSIGNINGKEYINPUT_MEMBER_HOSTED_ZONE_ID, val)?;
   65     70   
        }
   66     71   
        if let Some(ref val) = self.name {
   67     72   
            ser.write_string(&ACTIVATEKEYSIGNINGKEYINPUT_MEMBER_NAME, val)?;
   68     73   
        }
   69     74   
        Ok(())
   70     75   
    }
   71     76   
}
   72     77   
impl ActivateKeySigningKeyInput {
   73     78   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   74         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   75         -
        deserializer: &mut D,
          79  +
    pub fn deserialize(
          80  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   76     81   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   77     82   
        #[allow(unused_variables, unused_mut)]
   78     83   
        let mut builder = Self::builder();
   79     84   
        #[allow(
   80     85   
            unused_variables,
   81     86   
            unreachable_code,
   82     87   
            clippy::single_match,
   83     88   
            clippy::match_single_binding,
   84     89   
            clippy::diverging_sub_expression
   85     90   
        )]
   86         -
        deserializer.read_struct(&ACTIVATEKEYSIGNINGKEYINPUT_SCHEMA, (), |_, member, deser| {
          91  +
        deserializer.read_struct(&ACTIVATEKEYSIGNINGKEYINPUT_SCHEMA, &mut |member, deser| {
   87     92   
            match member.member_index() {
   88     93   
                Some(0) => {
   89     94   
                    builder.hosted_zone_id = Some(deser.read_string(member)?);
   90     95   
                }
   91     96   
                Some(1) => {
   92     97   
                    builder.name = Some(deser.read_string(member)?);
   93     98   
                }
   94     99   
                _ => {}
   95    100   
            }
   96    101   
            Ok(())
   97    102   
        })?;
         103  +
        builder.hosted_zone_id = builder.hosted_zone_id.or(Some(String::new()));
         104  +
        builder.name = builder.name.or(Some(String::new()));
   98    105   
        builder
   99    106   
            .build()
  100    107   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  101    108   
    }
  102    109   
}
         110  +
impl ActivateKeySigningKeyInput {
         111  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         112  +
    pub fn deserialize_with_response(
         113  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         114  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         115  +
        _status: u16,
         116  +
        _body: &[u8],
         117  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         118  +
        Self::deserialize(deserializer)
         119  +
    }
         120  +
}
  103    121   
impl ActivateKeySigningKeyInput {
  104    122   
    /// Creates a new builder-style object to manufacture [`ActivateKeySigningKeyInput`](crate::operation::activate_key_signing_key::ActivateKeySigningKeyInput).
  105    123   
    pub fn builder() -> crate::operation::activate_key_signing_key::builders::ActivateKeySigningKeyInputBuilder {
  106    124   
        crate::operation::activate_key_signing_key::builders::ActivateKeySigningKeyInputBuilder::default()
  107    125   
    }
  108    126   
}
  109    127   
  110    128   
/// A builder for [`ActivateKeySigningKeyInput`](crate::operation::activate_key_signing_key::ActivateKeySigningKeyInput).
  111    129   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  112    130   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/activate_key_signing_key/_activate_key_signing_key_output.rs

@@ -1,1 +96,143 @@
   18     18   
    "com.amazonaws.route53.synthetic",
   19     19   
    "ActivateKeySigningKeyOutput",
   20     20   
);
   21     21   
static ACTIVATEKEYSIGNINGKEYOUTPUT_MEMBER_CHANGE_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.route53.synthetic#ActivateKeySigningKeyOutput$ChangeInfo",
   24     24   
        "com.amazonaws.route53.synthetic",
   25     25   
        "ActivateKeySigningKeyOutput",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28         -
    "change_info",
          28  +
    "ChangeInfo",
   29     29   
    0,
   30     30   
);
          31  +
static ACTIVATEKEYSIGNINGKEYOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          32  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          33  +
    ::aws_smithy_schema::ShapeType::String,
          34  +
    "request_id",
          35  +
    1,
          36  +
)
          37  +
.with_http_header("x-amzn-requestid");
   31     38   
static ACTIVATEKEYSIGNINGKEYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     39   
    ACTIVATEKEYSIGNINGKEYOUTPUT_SCHEMA_ID,
   33     40   
    ::aws_smithy_schema::ShapeType::Structure,
   34         -
    &[&ACTIVATEKEYSIGNINGKEYOUTPUT_MEMBER_CHANGE_INFO],
          41  +
    &[
          42  +
        &ACTIVATEKEYSIGNINGKEYOUTPUT_MEMBER_CHANGE_INFO,
          43  +
        &ACTIVATEKEYSIGNINGKEYOUTPUT_MEMBER__REQUEST_ID,
          44  +
    ],
   35     45   
);
   36     46   
impl ActivateKeySigningKeyOutput {
   37     47   
    /// The schema for this shape.
   38     48   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ACTIVATEKEYSIGNINGKEYOUTPUT_SCHEMA;
   39     49   
}
   40     50   
impl ::aws_smithy_schema::serde::SerializableStruct for ActivateKeySigningKeyOutput {
   41     51   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     52   
    fn serialize_members(
   43     53   
        &self,
   44     54   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     55   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     56   
        if let Some(ref val) = self.change_info {
   47     57   
            ser.write_struct(&ACTIVATEKEYSIGNINGKEYOUTPUT_MEMBER_CHANGE_INFO, val)?;
   48     58   
        }
   49     59   
        Ok(())
   50     60   
    }
   51     61   
}
   52     62   
impl ActivateKeySigningKeyOutput {
   53     63   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     66   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     67   
        #[allow(unused_variables, unused_mut)]
   58     68   
        let mut builder = Self::builder();
   59     69   
        #[allow(
   60     70   
            unused_variables,
   61     71   
            unreachable_code,
   62     72   
            clippy::single_match,
   63     73   
            clippy::match_single_binding,
   64     74   
            clippy::diverging_sub_expression
   65     75   
        )]
   66         -
        deserializer.read_struct(&ACTIVATEKEYSIGNINGKEYOUTPUT_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&ACTIVATEKEYSIGNINGKEYOUTPUT_SCHEMA, &mut |member, deser| {
          77  +
            match member.member_index() {
          78  +
                Some(0) => {
          79  +
                    builder.change_info = Some(crate::types::ChangeInfo::deserialize(deser)?);
          80  +
                }
          81  +
                Some(1) => {
          82  +
                    builder._request_id = Some(deser.read_string(member)?);
          83  +
                }
          84  +
                _ => {}
          85  +
            }
          86  +
            Ok(())
          87  +
        })?;
          88  +
        Ok(builder.build())
          89  +
    }
          90  +
}
          91  +
impl ActivateKeySigningKeyOutput {
          92  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          93  +
    /// Header-bound members are read directly from headers, avoiding runtime
          94  +
    /// member iteration overhead. Body members are read via the deserializer.
          95  +
    pub fn deserialize_with_response(
          96  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          97  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          98  +
        _status: u16,
          99  +
        _body: &[u8],
         100  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         101  +
        #[allow(unused_variables, unused_mut)]
         102  +
        let mut builder = Self::builder();
         103  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         104  +
            builder._request_id = Some(val.to_string());
         105  +
        }
         106  +
        #[allow(
         107  +
            unused_variables,
         108  +
            unreachable_code,
         109  +
            clippy::single_match,
         110  +
            clippy::match_single_binding,
         111  +
            clippy::diverging_sub_expression
         112  +
        )]
         113  +
        deserializer.read_struct(&ACTIVATEKEYSIGNINGKEYOUTPUT_SCHEMA, &mut |member, deser| {
   67    114   
            match member.member_index() {
   68    115   
                Some(0) => {
   69    116   
                    builder.change_info = Some(crate::types::ChangeInfo::deserialize(deser)?);
   70    117   
                }
   71    118   
                _ => {}
   72    119   
            }
   73    120   
            Ok(())
   74    121   
        })?;
   75    122   
        Ok(builder.build())
   76    123   
    }

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/associate_vpc_with_hosted_zone.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 `AssociateVPCWithHostedZone`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct AssociateVPCWithHostedZone;
    6      6   
impl AssociateVPCWithHostedZone {
    7      7   
    /// Creates a new `AssociateVPCWithHostedZone`
    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::associate_vpc_with_hosted_zone::AssociateVpcWithHostedZoneInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::associate_vpc_with_hosted_zone::AssociateVpcWithHostedZoneOutput::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::associate_vpc_with_hosted_zone::AssociateVpcWithHostedZoneInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::associate_vpc_with_hosted_zone::AssociateVpcWithHostedZoneOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -127,133 +189,196 @@
  147    153   
                crate::operation::associate_vpc_with_hosted_zone::AssociateVPCWithHostedZoneError,
  148    154   
            >::new());
  149    155   
  150    156   
        ::std::borrow::Cow::Owned(rcb)
  151    157   
    }
  152    158   
}
  153    159   
  154    160   
#[derive(Debug)]
  155    161   
struct AssociateVPCWithHostedZoneResponseDeserializer;
  156    162   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for AssociateVPCWithHostedZoneResponseDeserializer {
  157         -
    fn deserialize_nonstreaming(
         163  +
    fn deserialize_nonstreaming_with_config(
  158    164   
        &self,
  159    165   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         166  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  160    167   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  161    168   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  162    169   
        let headers = response.headers();
  163    170   
        let body = response.body().bytes().expect("body loaded");
  164    171   
        #[allow(unused_mut)]
  165    172   
        let mut force_error = false;
  166    173   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  167    174   
        let parse_result = if !success && status != 200 || force_error {
  168    175   
            crate::protocol_serde::shape_associate_vpc_with_hosted_zone::de_associate_vpc_with_hosted_zone_http_error(status, headers, body)
  169    176   
        } else {

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/associate_vpc_with_hosted_zone/_associate_vpc_with_hosted_zone_input.rs

@@ -12,12 +160,177 @@
   32     32   
    "com.amazonaws.route53.synthetic",
   33     33   
    "AssociateVPCWithHostedZoneInput",
   34     34   
);
   35     35   
static ASSOCIATEVPCWITHHOSTEDZONEINPUT_MEMBER_HOSTED_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   36     36   
    ::aws_smithy_schema::ShapeId::from_static(
   37     37   
        "com.amazonaws.route53.synthetic#AssociateVPCWithHostedZoneInput$HostedZoneId",
   38     38   
        "com.amazonaws.route53.synthetic",
   39     39   
        "AssociateVPCWithHostedZoneInput",
   40     40   
    ),
   41     41   
    ::aws_smithy_schema::ShapeType::String,
   42         -
    "hosted_zone_id",
          42  +
    "HostedZoneId",
   43     43   
    0,
   44     44   
)
   45     45   
.with_http_label();
   46     46   
static ASSOCIATEVPCWITHHOSTEDZONEINPUT_MEMBER_VPC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   47     47   
    ::aws_smithy_schema::ShapeId::from_static(
   48     48   
        "com.amazonaws.route53.synthetic#AssociateVPCWithHostedZoneInput$VPC",
   49     49   
        "com.amazonaws.route53.synthetic",
   50     50   
        "AssociateVPCWithHostedZoneInput",
   51     51   
    ),
   52     52   
    ::aws_smithy_schema::ShapeType::Structure,
   53         -
    "vpc",
          53  +
    "VPC",
   54     54   
    1,
   55     55   
);
   56     56   
static ASSOCIATEVPCWITHHOSTEDZONEINPUT_MEMBER_COMMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "com.amazonaws.route53.synthetic#AssociateVPCWithHostedZoneInput$Comment",
   59     59   
        "com.amazonaws.route53.synthetic",
   60     60   
        "AssociateVPCWithHostedZoneInput",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "comment",
          63  +
    "Comment",
   64     64   
    2,
   65     65   
);
   66     66   
static ASSOCIATEVPCWITHHOSTEDZONEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   67     67   
    ASSOCIATEVPCWITHHOSTEDZONEINPUT_SCHEMA_ID,
   68     68   
    ::aws_smithy_schema::ShapeType::Structure,
   69     69   
    &[
   70     70   
        &ASSOCIATEVPCWITHHOSTEDZONEINPUT_MEMBER_HOSTED_ZONE_ID,
   71     71   
        &ASSOCIATEVPCWITHHOSTEDZONEINPUT_MEMBER_VPC,
   72     72   
        &ASSOCIATEVPCWITHHOSTEDZONEINPUT_MEMBER_COMMENT,
   73     73   
    ],
   74         -
);
          74  +
)
          75  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
          76  +
    "POST",
          77  +
    "/2013-04-01/hostedzone/{HostedZoneId}/associatevpc",
          78  +
    None,
          79  +
));
   75     80   
impl AssociateVpcWithHostedZoneInput {
   76     81   
    /// The schema for this shape.
   77     82   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ASSOCIATEVPCWITHHOSTEDZONEINPUT_SCHEMA;
   78     83   
}
   79     84   
impl ::aws_smithy_schema::serde::SerializableStruct for AssociateVpcWithHostedZoneInput {
   80     85   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   81     86   
    fn serialize_members(
   82     87   
        &self,
   83     88   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   84     89   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   85     90   
        if let Some(ref val) = self.hosted_zone_id {
   86     91   
            ser.write_string(&ASSOCIATEVPCWITHHOSTEDZONEINPUT_MEMBER_HOSTED_ZONE_ID, val)?;
   87     92   
        }
   88     93   
        if let Some(ref val) = self.vpc {
   89     94   
            ser.write_struct(&ASSOCIATEVPCWITHHOSTEDZONEINPUT_MEMBER_VPC, val)?;
   90     95   
        }
   91     96   
        if let Some(ref val) = self.comment {
   92     97   
            ser.write_string(&ASSOCIATEVPCWITHHOSTEDZONEINPUT_MEMBER_COMMENT, val)?;
   93     98   
        }
   94     99   
        Ok(())
   95    100   
    }
   96    101   
}
   97    102   
impl AssociateVpcWithHostedZoneInput {
   98    103   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   99         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  100         -
        deserializer: &mut D,
         104  +
    pub fn deserialize(
         105  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  101    106   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  102    107   
        #[allow(unused_variables, unused_mut)]
  103    108   
        let mut builder = Self::builder();
  104    109   
        #[allow(
  105    110   
            unused_variables,
  106    111   
            unreachable_code,
  107    112   
            clippy::single_match,
  108    113   
            clippy::match_single_binding,
  109    114   
            clippy::diverging_sub_expression
  110    115   
        )]
  111         -
        deserializer.read_struct(&ASSOCIATEVPCWITHHOSTEDZONEINPUT_SCHEMA, (), |_, member, deser| {
         116  +
        deserializer.read_struct(&ASSOCIATEVPCWITHHOSTEDZONEINPUT_SCHEMA, &mut |member, deser| {
  112    117   
            match member.member_index() {
  113    118   
                Some(0) => {
  114    119   
                    builder.hosted_zone_id = Some(deser.read_string(member)?);
  115    120   
                }
  116    121   
                Some(1) => {
  117    122   
                    builder.vpc = Some(crate::types::Vpc::deserialize(deser)?);
  118    123   
                }
  119    124   
                Some(2) => {
  120    125   
                    builder.comment = Some(deser.read_string(member)?);
  121    126   
                }
  122    127   
                _ => {}
  123    128   
            }
  124    129   
            Ok(())
  125    130   
        })?;
         131  +
        builder.hosted_zone_id = builder.hosted_zone_id.or(Some(String::new()));
  126    132   
        builder
  127    133   
            .build()
  128    134   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  129    135   
    }
  130    136   
}
         137  +
impl AssociateVpcWithHostedZoneInput {
         138  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         139  +
    pub fn deserialize_with_response(
         140  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         141  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         142  +
        _status: u16,
         143  +
        _body: &[u8],
         144  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         145  +
        Self::deserialize(deserializer)
         146  +
    }
         147  +
}
  131    148   
impl AssociateVpcWithHostedZoneInput {
  132    149   
    /// Creates a new builder-style object to manufacture [`AssociateVpcWithHostedZoneInput`](crate::operation::associate_vpc_with_hosted_zone::AssociateVpcWithHostedZoneInput).
  133    150   
    pub fn builder() -> crate::operation::associate_vpc_with_hosted_zone::builders::AssociateVpcWithHostedZoneInputBuilder {
  134    151   
        crate::operation::associate_vpc_with_hosted_zone::builders::AssociateVpcWithHostedZoneInputBuilder::default()
  135    152   
    }
  136    153   
}
  137    154   
  138    155   
/// A builder for [`AssociateVpcWithHostedZoneInput`](crate::operation::associate_vpc_with_hosted_zone::AssociateVpcWithHostedZoneInput).
  139    156   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  140    157   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/associate_vpc_with_hosted_zone/_associate_vpc_with_hosted_zone_output.rs

@@ -1,1 +97,144 @@
   19     19   
    "com.amazonaws.route53.synthetic",
   20     20   
    "AssociateVPCWithHostedZoneOutput",
   21     21   
);
   22     22   
static ASSOCIATEVPCWITHHOSTEDZONEOUTPUT_MEMBER_CHANGE_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.route53.synthetic#AssociateVPCWithHostedZoneOutput$ChangeInfo",
   25     25   
        "com.amazonaws.route53.synthetic",
   26     26   
        "AssociateVPCWithHostedZoneOutput",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29         -
    "change_info",
          29  +
    "ChangeInfo",
   30     30   
    0,
   31     31   
);
          32  +
static ASSOCIATEVPCWITHHOSTEDZONEOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          33  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          34  +
    ::aws_smithy_schema::ShapeType::String,
          35  +
    "request_id",
          36  +
    1,
          37  +
)
          38  +
.with_http_header("x-amzn-requestid");
   32     39   
static ASSOCIATEVPCWITHHOSTEDZONEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     40   
    ASSOCIATEVPCWITHHOSTEDZONEOUTPUT_SCHEMA_ID,
   34     41   
    ::aws_smithy_schema::ShapeType::Structure,
   35         -
    &[&ASSOCIATEVPCWITHHOSTEDZONEOUTPUT_MEMBER_CHANGE_INFO],
          42  +
    &[
          43  +
        &ASSOCIATEVPCWITHHOSTEDZONEOUTPUT_MEMBER_CHANGE_INFO,
          44  +
        &ASSOCIATEVPCWITHHOSTEDZONEOUTPUT_MEMBER__REQUEST_ID,
          45  +
    ],
   36     46   
);
   37     47   
impl AssociateVpcWithHostedZoneOutput {
   38     48   
    /// The schema for this shape.
   39     49   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ASSOCIATEVPCWITHHOSTEDZONEOUTPUT_SCHEMA;
   40     50   
}
   41     51   
impl ::aws_smithy_schema::serde::SerializableStruct for AssociateVpcWithHostedZoneOutput {
   42     52   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   43     53   
    fn serialize_members(
   44     54   
        &self,
   45     55   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   46     56   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     57   
        if let Some(ref val) = self.change_info {
   48     58   
            ser.write_struct(&ASSOCIATEVPCWITHHOSTEDZONEOUTPUT_MEMBER_CHANGE_INFO, val)?;
   49     59   
        }
   50     60   
        Ok(())
   51     61   
    }
   52     62   
}
   53     63   
impl AssociateVpcWithHostedZoneOutput {
   54     64   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   55         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   56         -
        deserializer: &mut D,
          65  +
    pub fn deserialize(
          66  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   57     67   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   58     68   
        #[allow(unused_variables, unused_mut)]
   59     69   
        let mut builder = Self::builder();
   60     70   
        #[allow(
   61     71   
            unused_variables,
   62     72   
            unreachable_code,
   63     73   
            clippy::single_match,
   64     74   
            clippy::match_single_binding,
   65     75   
            clippy::diverging_sub_expression
   66     76   
        )]
   67         -
        deserializer.read_struct(&ASSOCIATEVPCWITHHOSTEDZONEOUTPUT_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&ASSOCIATEVPCWITHHOSTEDZONEOUTPUT_SCHEMA, &mut |member, deser| {
          78  +
            match member.member_index() {
          79  +
                Some(0) => {
          80  +
                    builder.change_info = Some(crate::types::ChangeInfo::deserialize(deser)?);
          81  +
                }
          82  +
                Some(1) => {
          83  +
                    builder._request_id = Some(deser.read_string(member)?);
          84  +
                }
          85  +
                _ => {}
          86  +
            }
          87  +
            Ok(())
          88  +
        })?;
          89  +
        Ok(builder.build())
          90  +
    }
          91  +
}
          92  +
impl AssociateVpcWithHostedZoneOutput {
          93  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          94  +
    /// Header-bound members are read directly from headers, avoiding runtime
          95  +
    /// member iteration overhead. Body members are read via the deserializer.
          96  +
    pub fn deserialize_with_response(
          97  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          98  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          99  +
        _status: u16,
         100  +
        _body: &[u8],
         101  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         102  +
        #[allow(unused_variables, unused_mut)]
         103  +
        let mut builder = Self::builder();
         104  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         105  +
            builder._request_id = Some(val.to_string());
         106  +
        }
         107  +
        #[allow(
         108  +
            unused_variables,
         109  +
            unreachable_code,
         110  +
            clippy::single_match,
         111  +
            clippy::match_single_binding,
         112  +
            clippy::diverging_sub_expression
         113  +
        )]
         114  +
        deserializer.read_struct(&ASSOCIATEVPCWITHHOSTEDZONEOUTPUT_SCHEMA, &mut |member, deser| {
   68    115   
            match member.member_index() {
   69    116   
                Some(0) => {
   70    117   
                    builder.change_info = Some(crate::types::ChangeInfo::deserialize(deser)?);
   71    118   
                }
   72    119   
                _ => {}
   73    120   
            }
   74    121   
            Ok(())
   75    122   
        })?;
   76    123   
        Ok(builder.build())
   77    124   
    }

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/change_cidr_collection/_change_cidr_collection_input.rs

@@ -25,25 +191,202 @@
   45     45   
    "com.amazonaws.route53.synthetic",
   46     46   
    "ChangeCidrCollectionInput",
   47     47   
);
   48     48   
static CHANGECIDRCOLLECTIONINPUT_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static(
   50     50   
        "com.amazonaws.route53.synthetic#ChangeCidrCollectionInput$Id",
   51     51   
        "com.amazonaws.route53.synthetic",
   52     52   
        "ChangeCidrCollectionInput",
   53     53   
    ),
   54     54   
    ::aws_smithy_schema::ShapeType::String,
   55         -
    "id",
          55  +
    "Id",
   56     56   
    0,
   57     57   
)
   58     58   
.with_http_label();
   59     59   
static CHANGECIDRCOLLECTIONINPUT_MEMBER_COLLECTION_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.route53.synthetic#ChangeCidrCollectionInput$CollectionVersion",
   62     62   
        "com.amazonaws.route53.synthetic",
   63     63   
        "ChangeCidrCollectionInput",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::Long,
   66         -
    "collection_version",
          66  +
    "CollectionVersion",
   67     67   
    1,
   68     68   
);
   69     69   
static CHANGECIDRCOLLECTIONINPUT_MEMBER_CHANGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.route53.synthetic#ChangeCidrCollectionInput$Changes",
   72     72   
        "com.amazonaws.route53.synthetic",
   73     73   
        "ChangeCidrCollectionInput",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::List,
   76         -
    "changes",
          76  +
    "Changes",
   77     77   
    2,
   78     78   
);
   79     79   
static CHANGECIDRCOLLECTIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   80     80   
    CHANGECIDRCOLLECTIONINPUT_SCHEMA_ID,
   81     81   
    ::aws_smithy_schema::ShapeType::Structure,
   82     82   
    &[
   83     83   
        &CHANGECIDRCOLLECTIONINPUT_MEMBER_ID,
   84     84   
        &CHANGECIDRCOLLECTIONINPUT_MEMBER_COLLECTION_VERSION,
   85     85   
        &CHANGECIDRCOLLECTIONINPUT_MEMBER_CHANGES,
   86     86   
    ],
   87         -
);
          87  +
)
          88  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/2013-04-01/cidrcollection/{Id}", None));
   88     89   
impl ChangeCidrCollectionInput {
   89     90   
    /// The schema for this shape.
   90     91   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CHANGECIDRCOLLECTIONINPUT_SCHEMA;
   91     92   
}
   92     93   
impl ::aws_smithy_schema::serde::SerializableStruct for ChangeCidrCollectionInput {
   93     94   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   94     95   
    fn serialize_members(
   95     96   
        &self,
   96     97   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   97     98   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   98     99   
        if let Some(ref val) = self.id {
   99    100   
            ser.write_string(&CHANGECIDRCOLLECTIONINPUT_MEMBER_ID, val)?;
  100    101   
        }
  101    102   
        if let Some(ref val) = self.collection_version {
  102    103   
            ser.write_long(&CHANGECIDRCOLLECTIONINPUT_MEMBER_COLLECTION_VERSION, *val)?;
  103    104   
        }
  104    105   
        if let Some(ref val) = self.changes {
  105    106   
            ser.write_list(
  106    107   
                &CHANGECIDRCOLLECTIONINPUT_MEMBER_CHANGES,
  107    108   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  108    109   
                    for item in val {
  109    110   
                        ser.write_struct(crate::types::CidrCollectionChange::SCHEMA, item)?;
  110    111   
                    }
  111    112   
                    Ok(())
  112    113   
                },
  113    114   
            )?;
  114    115   
        }
  115    116   
        Ok(())
  116    117   
    }
  117    118   
}
  118    119   
impl ChangeCidrCollectionInput {
  119    120   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  120         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  121         -
        deserializer: &mut D,
         121  +
    pub fn deserialize(
         122  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  122    123   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  123    124   
        #[allow(unused_variables, unused_mut)]
  124    125   
        let mut builder = Self::builder();
  125    126   
        #[allow(
  126    127   
            unused_variables,
  127    128   
            unreachable_code,
  128    129   
            clippy::single_match,
  129    130   
            clippy::match_single_binding,
  130    131   
            clippy::diverging_sub_expression
  131    132   
        )]
  132         -
        deserializer.read_struct(&CHANGECIDRCOLLECTIONINPUT_SCHEMA, (), |_, member, deser| {
         133  +
        deserializer.read_struct(&CHANGECIDRCOLLECTIONINPUT_SCHEMA, &mut |member, deser| {
  133    134   
            match member.member_index() {
  134    135   
                Some(0) => {
  135    136   
                    builder.id = Some(deser.read_string(member)?);
  136    137   
                }
  137    138   
                Some(1) => {
  138    139   
                    builder.collection_version = Some(deser.read_long(member)?);
  139    140   
                }
  140    141   
                Some(2) => {
  141    142   
                    builder.changes = Some({
  142         -
                        let container = if let Some(cap) = deser.container_size() {
  143         -
                            Vec::with_capacity(cap)
  144         -
                        } else {
  145         -
                            Vec::new()
  146         -
                        };
  147         -
                        deser.read_list(member, container, |mut list, deser| {
  148         -
                            list.push(crate::types::CidrCollectionChange::deserialize(deser)?);
  149         -
                            Ok(list)
  150         -
                        })?
         143  +
                        let mut container = Vec::new();
         144  +
                        deser.read_list(member, &mut |deser| {
         145  +
                            container.push(crate::types::CidrCollectionChange::deserialize(deser)?);
         146  +
                            Ok(())
         147  +
                        })?;
         148  +
                        container
  151    149   
                    });
  152    150   
                }
  153    151   
                _ => {}
  154    152   
            }
  155    153   
            Ok(())
  156    154   
        })?;
         155  +
        builder.id = builder.id.or(Some(String::new()));
         156  +
        builder.changes = builder.changes.or(Some(Vec::new()));
  157    157   
        builder
  158    158   
            .build()
  159    159   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  160    160   
    }
  161    161   
}
         162  +
impl ChangeCidrCollectionInput {
         163  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         164  +
    pub fn deserialize_with_response(
         165  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         166  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         167  +
        _status: u16,
         168  +
        _body: &[u8],
         169  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         170  +
        Self::deserialize(deserializer)
         171  +
    }
         172  +
}
  162    173   
impl ChangeCidrCollectionInput {
  163    174   
    /// Creates a new builder-style object to manufacture [`ChangeCidrCollectionInput`](crate::operation::change_cidr_collection::ChangeCidrCollectionInput).
  164    175   
    pub fn builder() -> crate::operation::change_cidr_collection::builders::ChangeCidrCollectionInputBuilder {
  165    176   
        crate::operation::change_cidr_collection::builders::ChangeCidrCollectionInputBuilder::default()
  166    177   
    }
  167    178   
}
  168    179   
  169    180   
/// A builder for [`ChangeCidrCollectionInput`](crate::operation::change_cidr_collection::ChangeCidrCollectionInput).
  170    181   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  171    182   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/change_cidr_collection/_change_cidr_collection_output.rs

@@ -1,1 +98,145 @@
   19     19   
    "com.amazonaws.route53.synthetic",
   20     20   
    "ChangeCidrCollectionOutput",
   21     21   
);
   22     22   
static CHANGECIDRCOLLECTIONOUTPUT_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.route53.synthetic#ChangeCidrCollectionOutput$Id",
   25     25   
        "com.amazonaws.route53.synthetic",
   26     26   
        "ChangeCidrCollectionOutput",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "id",
          29  +
    "Id",
   30     30   
    0,
   31     31   
);
          32  +
static CHANGECIDRCOLLECTIONOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          33  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          34  +
    ::aws_smithy_schema::ShapeType::String,
          35  +
    "request_id",
          36  +
    1,
          37  +
)
          38  +
.with_http_header("x-amzn-requestid");
   32     39   
static CHANGECIDRCOLLECTIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     40   
    CHANGECIDRCOLLECTIONOUTPUT_SCHEMA_ID,
   34     41   
    ::aws_smithy_schema::ShapeType::Structure,
   35         -
    &[&CHANGECIDRCOLLECTIONOUTPUT_MEMBER_ID],
          42  +
    &[&CHANGECIDRCOLLECTIONOUTPUT_MEMBER_ID, &CHANGECIDRCOLLECTIONOUTPUT_MEMBER__REQUEST_ID],
   36     43   
);
   37     44   
impl ChangeCidrCollectionOutput {
   38     45   
    /// The schema for this shape.
   39     46   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CHANGECIDRCOLLECTIONOUTPUT_SCHEMA;
   40     47   
}
   41     48   
impl ::aws_smithy_schema::serde::SerializableStruct for ChangeCidrCollectionOutput {
   42     49   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   43     50   
    fn serialize_members(
   44     51   
        &self,
   45     52   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   46     53   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     54   
        {
   48     55   
            let val = &self.id;
   49     56   
            ser.write_string(&CHANGECIDRCOLLECTIONOUTPUT_MEMBER_ID, val)?;
   50     57   
        }
   51     58   
        Ok(())
   52     59   
    }
   53     60   
}
   54     61   
impl ChangeCidrCollectionOutput {
   55     62   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   56         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   57         -
        deserializer: &mut D,
          63  +
    pub fn deserialize(
          64  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   58     65   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   59     66   
        #[allow(unused_variables, unused_mut)]
   60     67   
        let mut builder = Self::builder();
   61     68   
        #[allow(
   62     69   
            unused_variables,
   63     70   
            unreachable_code,
   64     71   
            clippy::single_match,
   65     72   
            clippy::match_single_binding,
   66     73   
            clippy::diverging_sub_expression
   67     74   
        )]
   68         -
        deserializer.read_struct(&CHANGECIDRCOLLECTIONOUTPUT_SCHEMA, (), |_, member, deser| {
          75  +
        deserializer.read_struct(&CHANGECIDRCOLLECTIONOUTPUT_SCHEMA, &mut |member, deser| {
          76  +
            match member.member_index() {
          77  +
                Some(0) => {
          78  +
                    builder.id = Some(deser.read_string(member)?);
          79  +
                }
          80  +
                Some(1) => {
          81  +
                    builder._request_id = Some(deser.read_string(member)?);
          82  +
                }
          83  +
                _ => {}
          84  +
            }
          85  +
            Ok(())
          86  +
        })?;
          87  +
        builder.id = builder.id.or(Some(String::new()));
          88  +
        builder
          89  +
            .build()
          90  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
          91  +
    }
          92  +
}
          93  +
impl ChangeCidrCollectionOutput {
          94  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          95  +
    /// Header-bound members are read directly from headers, avoiding runtime
          96  +
    /// member iteration overhead. Body members are read via the deserializer.
          97  +
    pub fn deserialize_with_response(
          98  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          99  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         100  +
        _status: u16,
         101  +
        _body: &[u8],
         102  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         103  +
        #[allow(unused_variables, unused_mut)]
         104  +
        let mut builder = Self::builder();
         105  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         106  +
            builder._request_id = Some(val.to_string());
         107  +
        }
         108  +
        #[allow(
         109  +
            unused_variables,
         110  +
            unreachable_code,
         111  +
            clippy::single_match,
         112  +
            clippy::match_single_binding,
         113  +
            clippy::diverging_sub_expression
         114  +
        )]
         115  +
        deserializer.read_struct(&CHANGECIDRCOLLECTIONOUTPUT_SCHEMA, &mut |member, deser| {
   69    116   
            match member.member_index() {
   70    117   
                Some(0) => {
   71    118   
                    builder.id = Some(deser.read_string(member)?);
   72    119   
                }
   73    120   
                _ => {}
   74    121   
            }
   75    122   
            Ok(())
   76    123   
        })?;
   77    124   
        builder
   78    125   
            .build()

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/change_resource_record_sets.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 `ChangeResourceRecordSets`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ChangeResourceRecordSets;
    6      6   
impl ChangeResourceRecordSets {
    7      7   
    /// Creates a new `ChangeResourceRecordSets`
    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::change_resource_record_sets::ChangeResourceRecordSetsInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::change_resource_record_sets::ChangeResourceRecordSetsOutput::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::change_resource_record_sets::ChangeResourceRecordSetsInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::change_resource_record_sets::ChangeResourceRecordSetsOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::change_resource_record_sets::ChangeResourceRecordSetsError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -121,127 +183,190 @@
  141    147   
                crate::operation::change_resource_record_sets::ChangeResourceRecordSetsError,
  142    148   
            >::new());
  143    149   
  144    150   
        ::std::borrow::Cow::Owned(rcb)
  145    151   
    }
  146    152   
}
  147    153   
  148    154   
#[derive(Debug)]
  149    155   
struct ChangeResourceRecordSetsResponseDeserializer;
  150    156   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ChangeResourceRecordSetsResponseDeserializer {
  151         -
    fn deserialize_nonstreaming(
         157  +
    fn deserialize_nonstreaming_with_config(
  152    158   
        &self,
  153    159   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         160  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  154    161   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  155    162   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  156    163   
        let headers = response.headers();
  157    164   
        let body = response.body().bytes().expect("body loaded");
  158    165   
        #[allow(unused_mut)]
  159    166   
        let mut force_error = false;
  160    167   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  161    168   
        let parse_result = if !success && status != 200 || force_error {
  162    169   
            crate::protocol_serde::shape_change_resource_record_sets::de_change_resource_record_sets_http_error(status, headers, body)
  163    170   
        } else {