AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12

Files changed:

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_hosted_zone_count/_get_hosted_zone_count_input.rs

@@ -1,1 +71,85 @@
    3      3   
/// <p>A request to retrieve a count of all the hosted zones that are associated with the current Amazon Web Services account.</p>
    4      4   
#[non_exhaustive]
    5      5   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    6      6   
pub struct GetHostedZoneCountInput {}
    7      7   
static GETHOSTEDZONECOUNTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
    8      8   
    "com.amazonaws.route53.synthetic#GetHostedZoneCountInput",
    9      9   
    "com.amazonaws.route53.synthetic",
   10     10   
    "GetHostedZoneCountInput",
   11     11   
);
   12     12   
static GETHOSTEDZONECOUNTINPUT_SCHEMA: ::aws_smithy_schema::Schema =
   13         -
    ::aws_smithy_schema::Schema::new_struct(GETHOSTEDZONECOUNTINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
          13  +
    ::aws_smithy_schema::Schema::new_struct(GETHOSTEDZONECOUNTINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[])
          14  +
        .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/2013-04-01/hostedzonecount", None));
   14     15   
impl GetHostedZoneCountInput {
   15     16   
    /// The schema for this shape.
   16     17   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETHOSTEDZONECOUNTINPUT_SCHEMA;
   17     18   
}
   18     19   
impl ::aws_smithy_schema::serde::SerializableStruct for GetHostedZoneCountInput {
   19     20   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   20     21   
    fn serialize_members(
   21     22   
        &self,
   22     23   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   23     24   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   24     25   
        Ok(())
   25     26   
    }
   26     27   
}
   27     28   
impl GetHostedZoneCountInput {
   28     29   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   29         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   30         -
        deserializer: &mut D,
          30  +
    pub fn deserialize(
          31  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   31     32   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   32     33   
        #[allow(unused_variables, unused_mut)]
   33     34   
        let mut builder = Self::builder();
   34     35   
        #[allow(
   35     36   
            unused_variables,
   36     37   
            unreachable_code,
   37     38   
            clippy::single_match,
   38     39   
            clippy::match_single_binding,
   39     40   
            clippy::diverging_sub_expression
   40     41   
        )]
   41         -
        deserializer.read_struct(&GETHOSTEDZONECOUNTINPUT_SCHEMA, (), |_, member, deser| {
          42  +
        deserializer.read_struct(&GETHOSTEDZONECOUNTINPUT_SCHEMA, &mut |member, deser| {
   42     43   
            match member.member_index() {
   43     44   
                _ => {}
   44     45   
            }
   45     46   
            Ok(())
   46     47   
        })?;
   47     48   
        builder
   48     49   
            .build()
   49     50   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   50     51   
    }
   51     52   
}
          53  +
impl GetHostedZoneCountInput {
          54  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          55  +
    pub fn deserialize_with_response(
          56  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          57  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          58  +
        _status: u16,
          59  +
        _body: &[u8],
          60  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          61  +
        Self::builder()
          62  +
            .build()
          63  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
          64  +
    }
          65  +
}
   52     66   
impl GetHostedZoneCountInput {
   53     67   
    /// Creates a new builder-style object to manufacture [`GetHostedZoneCountInput`](crate::operation::get_hosted_zone_count::GetHostedZoneCountInput).
   54     68   
    pub fn builder() -> crate::operation::get_hosted_zone_count::builders::GetHostedZoneCountInputBuilder {
   55     69   
        crate::operation::get_hosted_zone_count::builders::GetHostedZoneCountInputBuilder::default()
   56     70   
    }
   57     71   
}
   58     72   
   59     73   
/// A builder for [`GetHostedZoneCountInput`](crate::operation::get_hosted_zone_count::GetHostedZoneCountInput).
   60     74   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   61     75   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_hosted_zone_count/_get_hosted_zone_count_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_hosted_zone_limit.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 `GetHostedZoneLimit`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetHostedZoneLimit;
    6      6   
impl GetHostedZoneLimit {
    7      7   
    /// Creates a new `GetHostedZoneLimit`
    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::get_hosted_zone_limit::GetHostedZoneLimitInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_hosted_zone_limit::GetHostedZoneLimitOutput::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::get_hosted_zone_limit::GetHostedZoneLimitInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_hosted_zone_limit::GetHostedZoneLimitOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_hosted_zone_limit::GetHostedZoneLimitError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -121,125 +183,188 @@
  141    145   
                crate::operation::get_hosted_zone_limit::GetHostedZoneLimitError,
  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 GetHostedZoneLimitResponseDeserializer;
  150    154   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetHostedZoneLimitResponseDeserializer {
  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_get_hosted_zone_limit::de_get_hosted_zone_limit_http_error(status, headers, body)
  163    168   
        } else {

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_hosted_zone_limit/_get_hosted_zone_limit_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_hosted_zone_limit/_get_hosted_zone_limit_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_query_logging_config.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 `GetQueryLoggingConfig`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetQueryLoggingConfig;
    6      6   
impl GetQueryLoggingConfig {
    7      7   
    /// Creates a new `GetQueryLoggingConfig`
    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::get_query_logging_config::GetQueryLoggingConfigInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_query_logging_config::GetQueryLoggingConfigOutput::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::get_query_logging_config::GetQueryLoggingConfigInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_query_logging_config::GetQueryLoggingConfigOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_query_logging_config::GetQueryLoggingConfigError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -118,122 +180,185 @@
  138    142   
                crate::operation::get_query_logging_config::GetQueryLoggingConfigError,
  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 GetQueryLoggingConfigResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetQueryLoggingConfigResponseDeserializer {
  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_get_query_logging_config::de_get_query_logging_config_http_error(status, headers, body)
  160    165   
        } else {

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_query_logging_config/_get_query_logging_config_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_query_logging_config/_get_query_logging_config_output.rs

@@ -1,1 +96,143 @@
   18     18   
    "com.amazonaws.route53.synthetic",
   19     19   
    "GetQueryLoggingConfigOutput",
   20     20   
);
   21     21   
static GETQUERYLOGGINGCONFIGOUTPUT_MEMBER_QUERY_LOGGING_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.route53.synthetic#GetQueryLoggingConfigOutput$QueryLoggingConfig",
   24     24   
        "com.amazonaws.route53.synthetic",
   25     25   
        "GetQueryLoggingConfigOutput",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28         -
    "query_logging_config",
          28  +
    "QueryLoggingConfig",
   29     29   
    0,
   30     30   
);
          31  +
static GETQUERYLOGGINGCONFIGOUTPUT_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 GETQUERYLOGGINGCONFIGOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     39   
    GETQUERYLOGGINGCONFIGOUTPUT_SCHEMA_ID,
   33     40   
    ::aws_smithy_schema::ShapeType::Structure,
   34         -
    &[&GETQUERYLOGGINGCONFIGOUTPUT_MEMBER_QUERY_LOGGING_CONFIG],
          41  +
    &[
          42  +
        &GETQUERYLOGGINGCONFIGOUTPUT_MEMBER_QUERY_LOGGING_CONFIG,
          43  +
        &GETQUERYLOGGINGCONFIGOUTPUT_MEMBER__REQUEST_ID,
          44  +
    ],
   35     45   
);
   36     46   
impl GetQueryLoggingConfigOutput {
   37     47   
    /// The schema for this shape.
   38     48   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETQUERYLOGGINGCONFIGOUTPUT_SCHEMA;
   39     49   
}
   40     50   
impl ::aws_smithy_schema::serde::SerializableStruct for GetQueryLoggingConfigOutput {
   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.query_logging_config {
   47     57   
            ser.write_struct(&GETQUERYLOGGINGCONFIGOUTPUT_MEMBER_QUERY_LOGGING_CONFIG, val)?;
   48     58   
        }
   49     59   
        Ok(())
   50     60   
    }
   51     61   
}
   52     62   
impl GetQueryLoggingConfigOutput {
   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(&GETQUERYLOGGINGCONFIGOUTPUT_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&GETQUERYLOGGINGCONFIGOUTPUT_SCHEMA, &mut |member, deser| {
          77  +
            match member.member_index() {
          78  +
                Some(0) => {
          79  +
                    builder.query_logging_config = Some(crate::types::QueryLoggingConfig::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 GetQueryLoggingConfigOutput {
          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(&GETQUERYLOGGINGCONFIGOUTPUT_SCHEMA, &mut |member, deser| {
   67    114   
            match member.member_index() {
   68    115   
                Some(0) => {
   69    116   
                    builder.query_logging_config = Some(crate::types::QueryLoggingConfig::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/get_reusable_delegation_set.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 `GetReusableDelegationSet`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetReusableDelegationSet;
    6      6   
impl GetReusableDelegationSet {
    7      7   
    /// Creates a new `GetReusableDelegationSet`
    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::get_reusable_delegation_set::GetReusableDelegationSetInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::get_reusable_delegation_set::GetReusableDelegationSetOutput::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::get_reusable_delegation_set::GetReusableDelegationSetInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::get_reusable_delegation_set::GetReusableDelegationSetOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::get_reusable_delegation_set::GetReusableDelegationSetError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -121,127 +183,190 @@
  141    147   
                crate::operation::get_reusable_delegation_set::GetReusableDelegationSetError,
  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 GetReusableDelegationSetResponseDeserializer;
  150    156   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetReusableDelegationSetResponseDeserializer {
  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_get_reusable_delegation_set::de_get_reusable_delegation_set_http_error(status, headers, body)
  163    170   
        } else {

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_reusable_delegation_set/_get_reusable_delegation_set_input.rs

@@ -1,1 +110,123 @@
   18     18   
    "com.amazonaws.route53.synthetic",
   19     19   
    "GetReusableDelegationSetInput",
   20     20   
);
   21     21   
static GETREUSABLEDELEGATIONSETINPUT_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.route53.synthetic#GetReusableDelegationSetInput$Id",
   24     24   
        "com.amazonaws.route53.synthetic",
   25     25   
        "GetReusableDelegationSetInput",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::String,
   28         -
    "id",
          28  +
    "Id",
   29     29   
    0,
   30     30   
)
   31     31   
.with_http_label();
   32     32   
static GETREUSABLEDELEGATIONSETINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     33   
    GETREUSABLEDELEGATIONSETINPUT_SCHEMA_ID,
   34     34   
    ::aws_smithy_schema::ShapeType::Structure,
   35     35   
    &[&GETREUSABLEDELEGATIONSETINPUT_MEMBER_ID],
   36         -
);
          36  +
)
          37  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/2013-04-01/delegationset/{Id}", None));
   37     38   
impl GetReusableDelegationSetInput {
   38     39   
    /// The schema for this shape.
   39     40   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETREUSABLEDELEGATIONSETINPUT_SCHEMA;
   40     41   
}
   41     42   
impl ::aws_smithy_schema::serde::SerializableStruct for GetReusableDelegationSetInput {
   42     43   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   43     44   
    fn serialize_members(
   44     45   
        &self,
   45     46   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   46     47   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     48   
        if let Some(ref val) = self.id {
   48     49   
            ser.write_string(&GETREUSABLEDELEGATIONSETINPUT_MEMBER_ID, val)?;
   49     50   
        }
   50     51   
        Ok(())
   51     52   
    }
   52     53   
}
   53     54   
impl GetReusableDelegationSetInput {
   54     55   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   55         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   56         -
        deserializer: &mut D,
          56  +
    pub fn deserialize(
          57  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   57     58   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   58     59   
        #[allow(unused_variables, unused_mut)]
   59     60   
        let mut builder = Self::builder();
   60     61   
        #[allow(
   61     62   
            unused_variables,
   62     63   
            unreachable_code,
   63     64   
            clippy::single_match,
   64     65   
            clippy::match_single_binding,
   65     66   
            clippy::diverging_sub_expression
   66     67   
        )]
   67         -
        deserializer.read_struct(&GETREUSABLEDELEGATIONSETINPUT_SCHEMA, (), |_, member, deser| {
          68  +
        deserializer.read_struct(&GETREUSABLEDELEGATIONSETINPUT_SCHEMA, &mut |member, deser| {
   68     69   
            match member.member_index() {
   69     70   
                Some(0) => {
   70     71   
                    builder.id = Some(deser.read_string(member)?);
   71     72   
                }
   72     73   
                _ => {}
   73     74   
            }
   74     75   
            Ok(())
   75     76   
        })?;
          77  +
        builder.id = builder.id.or(Some(String::new()));
   76     78   
        builder
   77     79   
            .build()
   78     80   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   79     81   
    }
   80     82   
}
          83  +
impl GetReusableDelegationSetInput {
          84  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          85  +
    pub fn deserialize_with_response(
          86  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          87  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          88  +
        _status: u16,
          89  +
        _body: &[u8],
          90  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          91  +
        Self::deserialize(deserializer)
          92  +
    }
          93  +
}
   81     94   
impl GetReusableDelegationSetInput {
   82     95   
    /// Creates a new builder-style object to manufacture [`GetReusableDelegationSetInput`](crate::operation::get_reusable_delegation_set::GetReusableDelegationSetInput).
   83     96   
    pub fn builder() -> crate::operation::get_reusable_delegation_set::builders::GetReusableDelegationSetInputBuilder {
   84     97   
        crate::operation::get_reusable_delegation_set::builders::GetReusableDelegationSetInputBuilder::default()
   85     98   
    }
   86     99   
}
   87    100   
   88    101   
/// A builder for [`GetReusableDelegationSetInput`](crate::operation::get_reusable_delegation_set::GetReusableDelegationSetInput).
   89    102   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   90    103   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_reusable_delegation_set/_get_reusable_delegation_set_output.rs

@@ -1,1 +97,144 @@
   19     19   
    "com.amazonaws.route53.synthetic",
   20     20   
    "GetReusableDelegationSetOutput",
   21     21   
);
   22     22   
static GETREUSABLEDELEGATIONSETOUTPUT_MEMBER_DELEGATION_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.route53.synthetic#GetReusableDelegationSetOutput$DelegationSet",
   25     25   
        "com.amazonaws.route53.synthetic",
   26     26   
        "GetReusableDelegationSetOutput",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29         -
    "delegation_set",
          29  +
    "DelegationSet",
   30     30   
    0,
   31     31   
);
          32  +
static GETREUSABLEDELEGATIONSETOUTPUT_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 GETREUSABLEDELEGATIONSETOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     40   
    GETREUSABLEDELEGATIONSETOUTPUT_SCHEMA_ID,
   34     41   
    ::aws_smithy_schema::ShapeType::Structure,
   35         -
    &[&GETREUSABLEDELEGATIONSETOUTPUT_MEMBER_DELEGATION_SET],
          42  +
    &[
          43  +
        &GETREUSABLEDELEGATIONSETOUTPUT_MEMBER_DELEGATION_SET,
          44  +
        &GETREUSABLEDELEGATIONSETOUTPUT_MEMBER__REQUEST_ID,
          45  +
    ],
   36     46   
);
   37     47   
impl GetReusableDelegationSetOutput {
   38     48   
    /// The schema for this shape.
   39     49   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETREUSABLEDELEGATIONSETOUTPUT_SCHEMA;
   40     50   
}
   41     51   
impl ::aws_smithy_schema::serde::SerializableStruct for GetReusableDelegationSetOutput {
   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.delegation_set {
   48     58   
            ser.write_struct(&GETREUSABLEDELEGATIONSETOUTPUT_MEMBER_DELEGATION_SET, val)?;
   49     59   
        }
   50     60   
        Ok(())
   51     61   
    }
   52     62   
}
   53     63   
impl GetReusableDelegationSetOutput {
   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(&GETREUSABLEDELEGATIONSETOUTPUT_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&GETREUSABLEDELEGATIONSETOUTPUT_SCHEMA, &mut |member, deser| {
          78  +
            match member.member_index() {
          79  +
                Some(0) => {
          80  +
                    builder.delegation_set = Some(crate::types::DelegationSet::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 GetReusableDelegationSetOutput {
          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(&GETREUSABLEDELEGATIONSETOUTPUT_SCHEMA, &mut |member, deser| {
   68    115   
            match member.member_index() {
   69    116   
                Some(0) => {
   70    117   
                    builder.delegation_set = Some(crate::types::DelegationSet::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/get_reusable_delegation_set_limit.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 `GetReusableDelegationSetLimit`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetReusableDelegationSetLimit;
    6      6   
impl GetReusableDelegationSetLimit {
    7      7   
    /// Creates a new `GetReusableDelegationSetLimit`
    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::get_reusable_delegation_set_limit::GetReusableDelegationSetLimitInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::get_reusable_delegation_set_limit::GetReusableDelegationSetLimitOutput::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::get_reusable_delegation_set_limit::GetReusableDelegationSetLimitInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::get_reusable_delegation_set_limit::GetReusableDelegationSetLimitOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::get_reusable_delegation_set_limit::GetReusableDelegationSetLimitError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -127,133 +189,196 @@
  147    153   
                crate::operation::get_reusable_delegation_set_limit::GetReusableDelegationSetLimitError,
  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 GetReusableDelegationSetLimitResponseDeserializer;
  156    162   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetReusableDelegationSetLimitResponseDeserializer {
  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_get_reusable_delegation_set_limit::de_get_reusable_delegation_set_limit_http_error(status, headers, body)
  169    176   
        } else {

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_reusable_delegation_set_limit/_get_reusable_delegation_set_limit_input.rs

@@ -4,4 +136,153 @@
   24     24   
    "com.amazonaws.route53.synthetic",
   25     25   
    "GetReusableDelegationSetLimitInput",
   26     26   
);
   27     27   
static GETREUSABLEDELEGATIONSETLIMITINPUT_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.route53.synthetic#GetReusableDelegationSetLimitInput$Type",
   30     30   
        "com.amazonaws.route53.synthetic",
   31     31   
        "GetReusableDelegationSetLimitInput",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "r##type",
          34  +
    "Type",
   35     35   
    0,
   36     36   
)
   37     37   
.with_http_label();
   38     38   
static GETREUSABLEDELEGATIONSETLIMITINPUT_MEMBER_DELEGATION_SET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.route53.synthetic#GetReusableDelegationSetLimitInput$DelegationSetId",
   41     41   
        "com.amazonaws.route53.synthetic",
   42     42   
        "GetReusableDelegationSetLimitInput",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45         -
    "delegation_set_id",
          45  +
    "DelegationSetId",
   46     46   
    1,
   47     47   
)
   48     48   
.with_http_label();
   49     49   
static GETREUSABLEDELEGATIONSETLIMITINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    GETREUSABLEDELEGATIONSETLIMITINPUT_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[
   53     53   
        &GETREUSABLEDELEGATIONSETLIMITINPUT_MEMBER_TYPE,
   54     54   
        &GETREUSABLEDELEGATIONSETLIMITINPUT_MEMBER_DELEGATION_SET_ID,
   55     55   
    ],
   56         -
);
          56  +
)
          57  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
          58  +
    "GET",
          59  +
    "/2013-04-01/reusabledelegationsetlimit/{DelegationSetId}/{Type}",
          60  +
    None,
          61  +
));
   57     62   
impl GetReusableDelegationSetLimitInput {
   58     63   
    /// The schema for this shape.
   59     64   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETREUSABLEDELEGATIONSETLIMITINPUT_SCHEMA;
   60     65   
}
   61     66   
impl ::aws_smithy_schema::serde::SerializableStruct for GetReusableDelegationSetLimitInput {
   62     67   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   63     68   
    fn serialize_members(
   64     69   
        &self,
   65     70   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   66     71   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   67     72   
        if let Some(ref val) = self.r#type {
   68     73   
            ser.write_string(&GETREUSABLEDELEGATIONSETLIMITINPUT_MEMBER_TYPE, val.as_str())?;
   69     74   
        }
   70     75   
        if let Some(ref val) = self.delegation_set_id {
   71     76   
            ser.write_string(&GETREUSABLEDELEGATIONSETLIMITINPUT_MEMBER_DELEGATION_SET_ID, val)?;
   72     77   
        }
   73     78   
        Ok(())
   74     79   
    }
   75     80   
}
   76     81   
impl GetReusableDelegationSetLimitInput {
   77     82   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   78         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   79         -
        deserializer: &mut D,
          83  +
    pub fn deserialize(
          84  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   80     85   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   81     86   
        #[allow(unused_variables, unused_mut)]
   82     87   
        let mut builder = Self::builder();
   83     88   
        #[allow(
   84     89   
            unused_variables,
   85     90   
            unreachable_code,
   86     91   
            clippy::single_match,
   87     92   
            clippy::match_single_binding,
   88     93   
            clippy::diverging_sub_expression
   89     94   
        )]
   90         -
        deserializer.read_struct(&GETREUSABLEDELEGATIONSETLIMITINPUT_SCHEMA, (), |_, member, deser| {
          95  +
        deserializer.read_struct(&GETREUSABLEDELEGATIONSETLIMITINPUT_SCHEMA, &mut |member, deser| {
   91     96   
            match member.member_index() {
   92     97   
                Some(0) => {
   93     98   
                    builder.r#type = Some(crate::types::ReusableDelegationSetLimitType::from(deser.read_string(member)?.as_str()));
   94     99   
                }
   95    100   
                Some(1) => {
   96    101   
                    builder.delegation_set_id = Some(deser.read_string(member)?);
   97    102   
                }
   98    103   
                _ => {}
   99    104   
            }
  100    105   
            Ok(())
  101    106   
        })?;
         107  +
        builder.delegation_set_id = builder.delegation_set_id.or(Some(String::new()));
  102    108   
        builder
  103    109   
            .build()
  104    110   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  105    111   
    }
  106    112   
}
         113  +
impl GetReusableDelegationSetLimitInput {
         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  +
}
  107    124   
impl GetReusableDelegationSetLimitInput {
  108    125   
    /// Creates a new builder-style object to manufacture [`GetReusableDelegationSetLimitInput`](crate::operation::get_reusable_delegation_set_limit::GetReusableDelegationSetLimitInput).
  109    126   
    pub fn builder() -> crate::operation::get_reusable_delegation_set_limit::builders::GetReusableDelegationSetLimitInputBuilder {
  110    127   
        crate::operation::get_reusable_delegation_set_limit::builders::GetReusableDelegationSetLimitInputBuilder::default()
  111    128   
    }
  112    129   
}
  113    130   
  114    131   
/// A builder for [`GetReusableDelegationSetLimitInput`](crate::operation::get_reusable_delegation_set_limit::GetReusableDelegationSetLimitInput).
  115    132   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  116    133   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_reusable_delegation_set_limit/_get_reusable_delegation_set_limit_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_traffic_policy.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 `GetTrafficPolicy`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetTrafficPolicy;
    6      6   
impl GetTrafficPolicy {
    7      7   
    /// Creates a new `GetTrafficPolicy`
    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::get_traffic_policy::GetTrafficPolicyInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_traffic_policy::GetTrafficPolicyOutput::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::get_traffic_policy::GetTrafficPolicyInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_traffic_policy::GetTrafficPolicyOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_traffic_policy::GetTrafficPolicyError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -118,122 +180,185 @@
  138    142   
                crate::operation::get_traffic_policy::GetTrafficPolicyError,
  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 GetTrafficPolicyResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetTrafficPolicyResponseDeserializer {
  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_get_traffic_policy::de_get_traffic_policy_http_error(status, headers, body)
  160    165   
        } else {

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_traffic_policy/_get_traffic_policy_input.rs

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