AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_customer_gateway/_create_customer_gateway_output.rs

@@ -1,1 +98,145 @@
   19     19   
    "com.amazonaws.ec2.synthetic",
   20     20   
    "CreateCustomerGatewayOutput",
   21     21   
);
   22     22   
static CREATECUSTOMERGATEWAYOUTPUT_MEMBER_CUSTOMER_GATEWAY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.ec2.synthetic#CreateCustomerGatewayOutput$CustomerGateway",
   25     25   
        "com.amazonaws.ec2.synthetic",
   26     26   
        "CreateCustomerGatewayOutput",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29         -
    "customer_gateway",
          29  +
    "CustomerGateway",
   30     30   
    0,
   31     31   
)
   32     32   
.with_xml_name("customerGateway");
          33  +
static CREATECUSTOMERGATEWAYOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          34  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          35  +
    ::aws_smithy_schema::ShapeType::String,
          36  +
    "request_id",
          37  +
    1,
          38  +
)
          39  +
.with_http_header("x-amzn-requestid");
   33     40   
static CREATECUSTOMERGATEWAYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     41   
    CREATECUSTOMERGATEWAYOUTPUT_SCHEMA_ID,
   35     42   
    ::aws_smithy_schema::ShapeType::Structure,
   36         -
    &[&CREATECUSTOMERGATEWAYOUTPUT_MEMBER_CUSTOMER_GATEWAY],
          43  +
    &[
          44  +
        &CREATECUSTOMERGATEWAYOUTPUT_MEMBER_CUSTOMER_GATEWAY,
          45  +
        &CREATECUSTOMERGATEWAYOUTPUT_MEMBER__REQUEST_ID,
          46  +
    ],
   37     47   
);
   38     48   
impl CreateCustomerGatewayOutput {
   39     49   
    /// The schema for this shape.
   40     50   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATECUSTOMERGATEWAYOUTPUT_SCHEMA;
   41     51   
}
   42     52   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateCustomerGatewayOutput {
   43     53   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   44     54   
    fn serialize_members(
   45     55   
        &self,
   46     56   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   47     57   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   48     58   
        if let Some(ref val) = self.customer_gateway {
   49     59   
            ser.write_struct(&CREATECUSTOMERGATEWAYOUTPUT_MEMBER_CUSTOMER_GATEWAY, val)?;
   50     60   
        }
   51     61   
        Ok(())
   52     62   
    }
   53     63   
}
   54     64   
impl CreateCustomerGatewayOutput {
   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(&CREATECUSTOMERGATEWAYOUTPUT_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&CREATECUSTOMERGATEWAYOUTPUT_SCHEMA, &mut |member, deser| {
          79  +
            match member.member_index() {
          80  +
                Some(0) => {
          81  +
                    builder.customer_gateway = Some(crate::types::CustomerGateway::deserialize(deser)?);
          82  +
                }
          83  +
                Some(1) => {
          84  +
                    builder._request_id = Some(deser.read_string(member)?);
          85  +
                }
          86  +
                _ => {}
          87  +
            }
          88  +
            Ok(())
          89  +
        })?;
          90  +
        Ok(builder.build())
          91  +
    }
          92  +
}
          93  +
impl CreateCustomerGatewayOutput {
          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(&CREATECUSTOMERGATEWAYOUTPUT_SCHEMA, &mut |member, deser| {
   69    116   
            match member.member_index() {
   70    117   
                Some(0) => {
   71    118   
                    builder.customer_gateway = Some(crate::types::CustomerGateway::deserialize(deser)?);
   72    119   
                }
   73    120   
                _ => {}
   74    121   
            }
   75    122   
            Ok(())
   76    123   
        })?;
   77    124   
        Ok(builder.build())
   78    125   
    }

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_default_subnet/_create_default_subnet_input.rs

@@ -19,19 +183,194 @@
   39     39   
    "com.amazonaws.ec2.synthetic",
   40     40   
    "CreateDefaultSubnetInput",
   41     41   
);
   42     42   
static CREATEDEFAULTSUBNETINPUT_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.ec2.synthetic#CreateDefaultSubnetInput$AvailabilityZone",
   45     45   
        "com.amazonaws.ec2.synthetic",
   46     46   
        "CreateDefaultSubnetInput",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "availability_zone",
          49  +
    "AvailabilityZone",
   50     50   
    0,
   51     51   
);
   52     52   
static CREATEDEFAULTSUBNETINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.ec2.synthetic#CreateDefaultSubnetInput$DryRun",
   55     55   
        "com.amazonaws.ec2.synthetic",
   56     56   
        "CreateDefaultSubnetInput",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::Boolean,
   59         -
    "dry_run",
          59  +
    "DryRun",
   60     60   
    1,
   61     61   
);
   62     62   
static CREATEDEFAULTSUBNETINPUT_MEMBER_IPV6_NATIVE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.ec2.synthetic#CreateDefaultSubnetInput$Ipv6Native",
   65     65   
        "com.amazonaws.ec2.synthetic",
   66     66   
        "CreateDefaultSubnetInput",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::Boolean,
   69         -
    "ipv6_native",
          69  +
    "Ipv6Native",
   70     70   
    2,
   71     71   
);
   72     72   
static CREATEDEFAULTSUBNETINPUT_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.ec2.synthetic#CreateDefaultSubnetInput$AvailabilityZoneId",
   75     75   
        "com.amazonaws.ec2.synthetic",
   76     76   
        "CreateDefaultSubnetInput",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "availability_zone_id",
          79  +
    "AvailabilityZoneId",
   80     80   
    3,
   81     81   
);
   82     82   
static CREATEDEFAULTSUBNETINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   83     83   
    CREATEDEFAULTSUBNETINPUT_SCHEMA_ID,
   84     84   
    ::aws_smithy_schema::ShapeType::Structure,
   85     85   
    &[
   86     86   
        &CREATEDEFAULTSUBNETINPUT_MEMBER_AVAILABILITY_ZONE,
   87     87   
        &CREATEDEFAULTSUBNETINPUT_MEMBER_DRY_RUN,
   88     88   
        &CREATEDEFAULTSUBNETINPUT_MEMBER_IPV6_NATIVE,
   89     89   
        &CREATEDEFAULTSUBNETINPUT_MEMBER_AVAILABILITY_ZONE_ID,
   90     90   
    ],
   91     91   
);
   92     92   
impl CreateDefaultSubnetInput {
   93     93   
    /// The schema for this shape.
   94     94   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEDEFAULTSUBNETINPUT_SCHEMA;
   95     95   
}
   96     96   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateDefaultSubnetInput {
   97     97   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   98     98   
    fn serialize_members(
   99     99   
        &self,
  100    100   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  101    101   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  102    102   
        if let Some(ref val) = self.availability_zone {
  103    103   
            ser.write_string(&CREATEDEFAULTSUBNETINPUT_MEMBER_AVAILABILITY_ZONE, val)?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.dry_run {
  106    106   
            ser.write_boolean(&CREATEDEFAULTSUBNETINPUT_MEMBER_DRY_RUN, *val)?;
  107    107   
        }
  108    108   
        if let Some(ref val) = self.ipv6_native {
  109    109   
            ser.write_boolean(&CREATEDEFAULTSUBNETINPUT_MEMBER_IPV6_NATIVE, *val)?;
  110    110   
        }
  111    111   
        if let Some(ref val) = self.availability_zone_id {
  112    112   
            ser.write_string(&CREATEDEFAULTSUBNETINPUT_MEMBER_AVAILABILITY_ZONE_ID, val)?;
  113    113   
        }
  114    114   
        Ok(())
  115    115   
    }
  116    116   
}
  117    117   
impl CreateDefaultSubnetInput {
  118    118   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  119         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  120         -
        deserializer: &mut D,
         119  +
    pub fn deserialize(
         120  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  121    121   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  122    122   
        #[allow(unused_variables, unused_mut)]
  123    123   
        let mut builder = Self::builder();
  124    124   
        #[allow(
  125    125   
            unused_variables,
  126    126   
            unreachable_code,
  127    127   
            clippy::single_match,
  128    128   
            clippy::match_single_binding,
  129    129   
            clippy::diverging_sub_expression
  130    130   
        )]
  131         -
        deserializer.read_struct(&CREATEDEFAULTSUBNETINPUT_SCHEMA, (), |_, member, deser| {
         131  +
        deserializer.read_struct(&CREATEDEFAULTSUBNETINPUT_SCHEMA, &mut |member, deser| {
  132    132   
            match member.member_index() {
  133    133   
                Some(0) => {
  134    134   
                    builder.availability_zone = Some(deser.read_string(member)?);
  135    135   
                }
  136    136   
                Some(1) => {
  137    137   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  138    138   
                }
  139    139   
                Some(2) => {
  140    140   
                    builder.ipv6_native = Some(deser.read_boolean(member)?);
  141    141   
                }
  142    142   
                Some(3) => {
  143    143   
                    builder.availability_zone_id = Some(deser.read_string(member)?);
  144    144   
                }
  145    145   
                _ => {}
  146    146   
            }
  147    147   
            Ok(())
  148    148   
        })?;
  149    149   
        builder
  150    150   
            .build()
  151    151   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  152    152   
    }
  153    153   
}
         154  +
impl CreateDefaultSubnetInput {
         155  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         156  +
    pub fn deserialize_with_response(
         157  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         158  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         159  +
        _status: u16,
         160  +
        _body: &[u8],
         161  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         162  +
        Self::deserialize(deserializer)
         163  +
    }
         164  +
}
  154    165   
impl CreateDefaultSubnetInput {
  155    166   
    /// Creates a new builder-style object to manufacture [`CreateDefaultSubnetInput`](crate::operation::create_default_subnet::CreateDefaultSubnetInput).
  156    167   
    pub fn builder() -> crate::operation::create_default_subnet::builders::CreateDefaultSubnetInputBuilder {
  157    168   
        crate::operation::create_default_subnet::builders::CreateDefaultSubnetInputBuilder::default()
  158    169   
    }
  159    170   
}
  160    171   
  161    172   
/// A builder for [`CreateDefaultSubnetInput`](crate::operation::create_default_subnet::CreateDefaultSubnetInput).
  162    173   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  163    174   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_default_subnet/_create_default_subnet_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_default_vpc/_create_default_vpc_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_default_vpc/_create_default_vpc_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_delegate_mac_volume_ownership_task/_create_delegate_mac_volume_ownership_task_input.rs

@@ -74,74 +274,284 @@
   94     94   
    "com.amazonaws.ec2.synthetic",
   95     95   
    "CreateDelegateMacVolumeOwnershipTaskInput",
   96     96   
);
   97     97   
static CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.ec2.synthetic#CreateDelegateMacVolumeOwnershipTaskInput$ClientToken",
  100    100   
        "com.amazonaws.ec2.synthetic",
  101    101   
        "CreateDelegateMacVolumeOwnershipTaskInput",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::String,
  104         -
    "client_token",
         104  +
    "ClientToken",
  105    105   
    0,
  106    106   
);
  107    107   
static CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.ec2.synthetic#CreateDelegateMacVolumeOwnershipTaskInput$DryRun",
  110    110   
        "com.amazonaws.ec2.synthetic",
  111    111   
        "CreateDelegateMacVolumeOwnershipTaskInput",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::Boolean,
  114         -
    "dry_run",
         114  +
    "DryRun",
  115    115   
    1,
  116    116   
);
  117    117   
static CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.ec2.synthetic#CreateDelegateMacVolumeOwnershipTaskInput$InstanceId",
  120    120   
        "com.amazonaws.ec2.synthetic",
  121    121   
        "CreateDelegateMacVolumeOwnershipTaskInput",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::String,
  124         -
    "instance_id",
         124  +
    "InstanceId",
  125    125   
    2,
  126    126   
);
  127    127   
static CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_MAC_CREDENTIALS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static(
  129    129   
        "com.amazonaws.ec2.synthetic#CreateDelegateMacVolumeOwnershipTaskInput$MacCredentials",
  130    130   
        "com.amazonaws.ec2.synthetic",
  131    131   
        "CreateDelegateMacVolumeOwnershipTaskInput",
  132    132   
    ),
  133    133   
    ::aws_smithy_schema::ShapeType::String,
  134         -
    "mac_credentials",
         134  +
    "MacCredentials",
  135    135   
    3,
  136    136   
);
  137    137   
static CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static(
  139    139   
        "com.amazonaws.ec2.synthetic#CreateDelegateMacVolumeOwnershipTaskInput$TagSpecifications",
  140    140   
        "com.amazonaws.ec2.synthetic",
  141    141   
        "CreateDelegateMacVolumeOwnershipTaskInput",
  142    142   
    ),
  143    143   
    ::aws_smithy_schema::ShapeType::List,
  144         -
    "tag_specifications",
         144  +
    "TagSpecifications",
  145    145   
    4,
  146    146   
)
  147    147   
.with_xml_name("TagSpecification");
  148    148   
static CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  149    149   
    CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_SCHEMA_ID,
  150    150   
    ::aws_smithy_schema::ShapeType::Structure,
  151    151   
    &[
  152    152   
        &CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_CLIENT_TOKEN,
  153    153   
        &CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_DRY_RUN,
  154    154   
        &CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_INSTANCE_ID,
  155    155   
        &CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_MAC_CREDENTIALS,
  156    156   
        &CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_TAG_SPECIFICATIONS,
  157    157   
    ],
  158    158   
);
  159    159   
impl CreateDelegateMacVolumeOwnershipTaskInput {
  160    160   
    /// The schema for this shape.
  161    161   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_SCHEMA;
  162    162   
}
  163    163   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateDelegateMacVolumeOwnershipTaskInput {
  164    164   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  165    165   
    fn serialize_members(
  166    166   
        &self,
  167    167   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  168    168   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  169    169   
        if let Some(ref val) = self.client_token {
  170    170   
            ser.write_string(&CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_CLIENT_TOKEN, val)?;
  171    171   
        }
  172    172   
        if let Some(ref val) = self.dry_run {
  173    173   
            ser.write_boolean(&CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_DRY_RUN, *val)?;
  174    174   
        }
  175    175   
        if let Some(ref val) = self.instance_id {
  176    176   
            ser.write_string(&CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_INSTANCE_ID, val)?;
  177    177   
        }
  178    178   
        if let Some(ref val) = self.mac_credentials {
  179    179   
            ser.write_string(&CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_MAC_CREDENTIALS, val)?;
  180    180   
        }
  181    181   
        if let Some(ref val) = self.tag_specifications {
  182    182   
            ser.write_list(
  183    183   
                &CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_MEMBER_TAG_SPECIFICATIONS,
  184    184   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  185    185   
                    for item in val {
  186    186   
                        ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
  187    187   
                    }
  188    188   
                    Ok(())
  189    189   
                },
  190    190   
            )?;
  191    191   
        }
  192    192   
        Ok(())
  193    193   
    }
  194    194   
}
  195    195   
impl CreateDelegateMacVolumeOwnershipTaskInput {
  196    196   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  197         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  198         -
        deserializer: &mut D,
         197  +
    pub fn deserialize(
         198  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  199    199   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  200    200   
        #[allow(unused_variables, unused_mut)]
  201    201   
        let mut builder = Self::builder();
  202    202   
        #[allow(
  203    203   
            unused_variables,
  204    204   
            unreachable_code,
  205    205   
            clippy::single_match,
  206    206   
            clippy::match_single_binding,
  207    207   
            clippy::diverging_sub_expression
  208    208   
        )]
  209         -
        deserializer.read_struct(&CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_SCHEMA, (), |_, member, deser| {
         209  +
        deserializer.read_struct(&CREATEDELEGATEMACVOLUMEOWNERSHIPTASKINPUT_SCHEMA, &mut |member, deser| {
  210    210   
            match member.member_index() {
  211    211   
                Some(0) => {
  212    212   
                    builder.client_token = Some(deser.read_string(member)?);
  213    213   
                }
  214    214   
                Some(1) => {
  215    215   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  216    216   
                }
  217    217   
                Some(2) => {
  218    218   
                    builder.instance_id = Some(deser.read_string(member)?);
  219    219   
                }
  220    220   
                Some(3) => {
  221    221   
                    builder.mac_credentials = Some(deser.read_string(member)?);
  222    222   
                }
  223    223   
                Some(4) => {
  224    224   
                    builder.tag_specifications = Some({
  225         -
                        let container = if let Some(cap) = deser.container_size() {
  226         -
                            Vec::with_capacity(cap)
  227         -
                        } else {
  228         -
                            Vec::new()
  229         -
                        };
  230         -
                        deser.read_list(member, container, |mut list, deser| {
  231         -
                            list.push(crate::types::TagSpecification::deserialize(deser)?);
  232         -
                            Ok(list)
  233         -
                        })?
         225  +
                        let mut container = Vec::new();
         226  +
                        deser.read_list(member, &mut |deser| {
         227  +
                            container.push(crate::types::TagSpecification::deserialize(deser)?);
         228  +
                            Ok(())
         229  +
                        })?;
         230  +
                        container
  234    231   
                    });
  235    232   
                }
  236    233   
                _ => {}
  237    234   
            }
  238    235   
            Ok(())
  239    236   
        })?;
         237  +
        builder.instance_id = builder.instance_id.or(Some(String::new()));
         238  +
        builder.mac_credentials = builder.mac_credentials.or(Some(String::new()));
  240    239   
        builder
  241    240   
            .build()
  242    241   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  243    242   
    }
  244    243   
}
         244  +
impl CreateDelegateMacVolumeOwnershipTaskInput {
         245  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         246  +
    pub fn deserialize_with_response(
         247  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         248  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         249  +
        _status: u16,
         250  +
        _body: &[u8],
         251  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         252  +
        Self::deserialize(deserializer)
         253  +
    }
         254  +
}
  245    255   
impl CreateDelegateMacVolumeOwnershipTaskInput {
  246    256   
    /// Creates a new builder-style object to manufacture [`CreateDelegateMacVolumeOwnershipTaskInput`](crate::operation::create_delegate_mac_volume_ownership_task::CreateDelegateMacVolumeOwnershipTaskInput).
  247    257   
    pub fn builder() -> crate::operation::create_delegate_mac_volume_ownership_task::builders::CreateDelegateMacVolumeOwnershipTaskInputBuilder {
  248    258   
        crate::operation::create_delegate_mac_volume_ownership_task::builders::CreateDelegateMacVolumeOwnershipTaskInputBuilder::default()
  249    259   
    }
  250    260   
}
  251    261   
  252    262   
/// A builder for [`CreateDelegateMacVolumeOwnershipTaskInput`](crate::operation::create_delegate_mac_volume_ownership_task::CreateDelegateMacVolumeOwnershipTaskInput).
  253    263   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  254    264   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_delegate_mac_volume_ownership_task/_create_delegate_mac_volume_ownership_task_output.rs

@@ -1,1 +98,145 @@
   19     19   
    "CreateDelegateMacVolumeOwnershipTaskOutput",
   20     20   
);
   21     21   
static CREATEDELEGATEMACVOLUMEOWNERSHIPTASKOUTPUT_MEMBER_MAC_MODIFICATION_TASK: ::aws_smithy_schema::Schema =
   22     22   
    ::aws_smithy_schema::Schema::new_member(
   23     23   
        ::aws_smithy_schema::ShapeId::from_static(
   24     24   
            "com.amazonaws.ec2.synthetic#CreateDelegateMacVolumeOwnershipTaskOutput$MacModificationTask",
   25     25   
            "com.amazonaws.ec2.synthetic",
   26     26   
            "CreateDelegateMacVolumeOwnershipTaskOutput",
   27     27   
        ),
   28     28   
        ::aws_smithy_schema::ShapeType::Structure,
   29         -
        "mac_modification_task",
          29  +
        "MacModificationTask",
   30     30   
        0,
   31     31   
    )
   32     32   
    .with_xml_name("macModificationTask");
          33  +
static CREATEDELEGATEMACVOLUMEOWNERSHIPTASKOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          34  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          35  +
    ::aws_smithy_schema::ShapeType::String,
          36  +
    "request_id",
          37  +
    1,
          38  +
)
          39  +
.with_http_header("x-amzn-requestid");
   33     40   
static CREATEDELEGATEMACVOLUMEOWNERSHIPTASKOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     41   
    CREATEDELEGATEMACVOLUMEOWNERSHIPTASKOUTPUT_SCHEMA_ID,
   35     42   
    ::aws_smithy_schema::ShapeType::Structure,
   36         -
    &[&CREATEDELEGATEMACVOLUMEOWNERSHIPTASKOUTPUT_MEMBER_MAC_MODIFICATION_TASK],
          43  +
    &[
          44  +
        &CREATEDELEGATEMACVOLUMEOWNERSHIPTASKOUTPUT_MEMBER_MAC_MODIFICATION_TASK,
          45  +
        &CREATEDELEGATEMACVOLUMEOWNERSHIPTASKOUTPUT_MEMBER__REQUEST_ID,
          46  +
    ],
   37     47   
);
   38     48   
impl CreateDelegateMacVolumeOwnershipTaskOutput {
   39     49   
    /// The schema for this shape.
   40     50   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEDELEGATEMACVOLUMEOWNERSHIPTASKOUTPUT_SCHEMA;
   41     51   
}
   42     52   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateDelegateMacVolumeOwnershipTaskOutput {
   43     53   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   44     54   
    fn serialize_members(
   45     55   
        &self,
   46     56   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   47     57   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   48     58   
        if let Some(ref val) = self.mac_modification_task {
   49     59   
            ser.write_struct(&CREATEDELEGATEMACVOLUMEOWNERSHIPTASKOUTPUT_MEMBER_MAC_MODIFICATION_TASK, val)?;
   50     60   
        }
   51     61   
        Ok(())
   52     62   
    }
   53     63   
}
   54     64   
impl CreateDelegateMacVolumeOwnershipTaskOutput {
   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(&CREATEDELEGATEMACVOLUMEOWNERSHIPTASKOUTPUT_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&CREATEDELEGATEMACVOLUMEOWNERSHIPTASKOUTPUT_SCHEMA, &mut |member, deser| {
          79  +
            match member.member_index() {
          80  +
                Some(0) => {
          81  +
                    builder.mac_modification_task = Some(crate::types::MacModificationTask::deserialize(deser)?);
          82  +
                }
          83  +
                Some(1) => {
          84  +
                    builder._request_id = Some(deser.read_string(member)?);
          85  +
                }
          86  +
                _ => {}
          87  +
            }
          88  +
            Ok(())
          89  +
        })?;
          90  +
        Ok(builder.build())
          91  +
    }
          92  +
}
          93  +
impl CreateDelegateMacVolumeOwnershipTaskOutput {
          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(&CREATEDELEGATEMACVOLUMEOWNERSHIPTASKOUTPUT_SCHEMA, &mut |member, deser| {
   69    116   
            match member.member_index() {
   70    117   
                Some(0) => {
   71    118   
                    builder.mac_modification_task = Some(crate::types::MacModificationTask::deserialize(deser)?);
   72    119   
                }
   73    120   
                _ => {}
   74    121   
            }
   75    122   
            Ok(())
   76    123   
        })?;
   77    124   
        Ok(builder.build())
   78    125   
    }

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_dhcp_options/_create_dhcp_options_input.rs

@@ -13,13 +199,205 @@
   33     33   
    "com.amazonaws.ec2.synthetic",
   34     34   
    "CreateDhcpOptionsInput",
   35     35   
);
   36     36   
static CREATEDHCPOPTIONSINPUT_MEMBER_DHCP_CONFIGURATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static(
   38     38   
        "com.amazonaws.ec2.synthetic#CreateDhcpOptionsInput$DhcpConfigurations",
   39     39   
        "com.amazonaws.ec2.synthetic",
   40     40   
        "CreateDhcpOptionsInput",
   41     41   
    ),
   42     42   
    ::aws_smithy_schema::ShapeType::List,
   43         -
    "dhcp_configurations",
          43  +
    "DhcpConfigurations",
   44     44   
    0,
   45     45   
)
   46     46   
.with_xml_name("dhcpConfiguration");
   47     47   
static CREATEDHCPOPTIONSINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   48     48   
    ::aws_smithy_schema::ShapeId::from_static(
   49     49   
        "com.amazonaws.ec2.synthetic#CreateDhcpOptionsInput$TagSpecifications",
   50     50   
        "com.amazonaws.ec2.synthetic",
   51     51   
        "CreateDhcpOptionsInput",
   52     52   
    ),
   53     53   
    ::aws_smithy_schema::ShapeType::List,
   54         -
    "tag_specifications",
          54  +
    "TagSpecifications",
   55     55   
    1,
   56     56   
)
   57     57   
.with_xml_name("TagSpecification");
   58     58   
static CREATEDHCPOPTIONSINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static(
   60     60   
        "com.amazonaws.ec2.synthetic#CreateDhcpOptionsInput$DryRun",
   61     61   
        "com.amazonaws.ec2.synthetic",
   62     62   
        "CreateDhcpOptionsInput",
   63     63   
    ),
   64     64   
    ::aws_smithy_schema::ShapeType::Boolean,
   65         -
    "dry_run",
          65  +
    "DryRun",
   66     66   
    2,
   67     67   
)
   68     68   
.with_xml_name("dryRun");
   69     69   
static CREATEDHCPOPTIONSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   70     70   
    CREATEDHCPOPTIONSINPUT_SCHEMA_ID,
   71     71   
    ::aws_smithy_schema::ShapeType::Structure,
   72     72   
    &[
   73     73   
        &CREATEDHCPOPTIONSINPUT_MEMBER_DHCP_CONFIGURATIONS,
   74     74   
        &CREATEDHCPOPTIONSINPUT_MEMBER_TAG_SPECIFICATIONS,
   75     75   
        &CREATEDHCPOPTIONSINPUT_MEMBER_DRY_RUN,
   76     76   
    ],
   77     77   
);
   78     78   
impl CreateDhcpOptionsInput {
   79     79   
    /// The schema for this shape.
   80     80   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEDHCPOPTIONSINPUT_SCHEMA;
   81     81   
}
   82     82   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateDhcpOptionsInput {
   83     83   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   84     84   
    fn serialize_members(
   85     85   
        &self,
   86     86   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   87     87   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   88     88   
        if let Some(ref val) = self.dhcp_configurations {
   89     89   
            ser.write_list(
   90     90   
                &CREATEDHCPOPTIONSINPUT_MEMBER_DHCP_CONFIGURATIONS,
   91     91   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   92     92   
                    for item in val {
   93     93   
                        ser.write_struct(crate::types::NewDhcpConfiguration::SCHEMA, item)?;
   94     94   
                    }
   95     95   
                    Ok(())
   96     96   
                },
   97     97   
            )?;
   98     98   
        }
   99     99   
        if let Some(ref val) = self.tag_specifications {
  100    100   
            ser.write_list(
  101    101   
                &CREATEDHCPOPTIONSINPUT_MEMBER_TAG_SPECIFICATIONS,
  102    102   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  103    103   
                    for item in val {
  104    104   
                        ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
  105    105   
                    }
  106    106   
                    Ok(())
  107    107   
                },
  108    108   
            )?;
  109    109   
        }
  110    110   
        if let Some(ref val) = self.dry_run {
  111    111   
            ser.write_boolean(&CREATEDHCPOPTIONSINPUT_MEMBER_DRY_RUN, *val)?;
  112    112   
        }
  113    113   
        Ok(())
  114    114   
    }
  115    115   
}
  116    116   
impl CreateDhcpOptionsInput {
  117    117   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  118         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  119         -
        deserializer: &mut D,
         118  +
    pub fn deserialize(
         119  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  120    120   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  121    121   
        #[allow(unused_variables, unused_mut)]
  122    122   
        let mut builder = Self::builder();
  123    123   
        #[allow(
  124    124   
            unused_variables,
  125    125   
            unreachable_code,
  126    126   
            clippy::single_match,
  127    127   
            clippy::match_single_binding,
  128    128   
            clippy::diverging_sub_expression
  129    129   
        )]
  130         -
        deserializer.read_struct(&CREATEDHCPOPTIONSINPUT_SCHEMA, (), |_, member, deser| {
         130  +
        deserializer.read_struct(&CREATEDHCPOPTIONSINPUT_SCHEMA, &mut |member, deser| {
  131    131   
            match member.member_index() {
  132    132   
                Some(0) => {
  133    133   
                    builder.dhcp_configurations = Some({
  134         -
                        let container = if let Some(cap) = deser.container_size() {
  135         -
                            Vec::with_capacity(cap)
  136         -
                        } else {
  137         -
                            Vec::new()
  138         -
                        };
  139         -
                        deser.read_list(member, container, |mut list, deser| {
  140         -
                            list.push(crate::types::NewDhcpConfiguration::deserialize(deser)?);
  141         -
                            Ok(list)
  142         -
                        })?
         134  +
                        let mut container = Vec::new();
         135  +
                        deser.read_list(member, &mut |deser| {
         136  +
                            container.push(crate::types::NewDhcpConfiguration::deserialize(deser)?);
         137  +
                            Ok(())
         138  +
                        })?;
         139  +
                        container
  143    140   
                    });
  144    141   
                }
  145    142   
                Some(1) => {
  146    143   
                    builder.tag_specifications = Some({
  147         -
                        let container = if let Some(cap) = deser.container_size() {
  148         -
                            Vec::with_capacity(cap)
  149         -
                        } else {
  150         -
                            Vec::new()
  151         -
                        };
  152         -
                        deser.read_list(member, container, |mut list, deser| {
  153         -
                            list.push(crate::types::TagSpecification::deserialize(deser)?);
  154         -
                            Ok(list)
  155         -
                        })?
         144  +
                        let mut container = Vec::new();
         145  +
                        deser.read_list(member, &mut |deser| {
         146  +
                            container.push(crate::types::TagSpecification::deserialize(deser)?);
         147  +
                            Ok(())
         148  +
                        })?;
         149  +
                        container
  156    150   
                    });
  157    151   
                }
  158    152   
                Some(2) => {
  159    153   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  160    154   
                }
  161    155   
                _ => {}
  162    156   
            }
  163    157   
            Ok(())
  164    158   
        })?;
         159  +
        builder.dhcp_configurations = builder.dhcp_configurations.or(Some(Vec::new()));
  165    160   
        builder
  166    161   
            .build()
  167    162   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  168    163   
    }
  169    164   
}
         165  +
impl CreateDhcpOptionsInput {
         166  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         167  +
    pub fn deserialize_with_response(
         168  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         169  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         170  +
        _status: u16,
         171  +
        _body: &[u8],
         172  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         173  +
        Self::deserialize(deserializer)
         174  +
    }
         175  +
}
  170    176   
impl CreateDhcpOptionsInput {
  171    177   
    /// Creates a new builder-style object to manufacture [`CreateDhcpOptionsInput`](crate::operation::create_dhcp_options::CreateDhcpOptionsInput).
  172    178   
    pub fn builder() -> crate::operation::create_dhcp_options::builders::CreateDhcpOptionsInputBuilder {
  173    179   
        crate::operation::create_dhcp_options::builders::CreateDhcpOptionsInputBuilder::default()
  174    180   
    }
  175    181   
}
  176    182   
  177    183   
/// A builder for [`CreateDhcpOptionsInput`](crate::operation::create_dhcp_options::CreateDhcpOptionsInput).
  178    184   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  179    185   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_dhcp_options/_create_dhcp_options_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_egress_only_internet_gateway/_create_egress_only_internet_gateway_input.rs

@@ -17,17 +200,209 @@
   37     37   
    "com.amazonaws.ec2.synthetic",
   38     38   
    "CreateEgressOnlyInternetGatewayInput",
   39     39   
);
   40     40   
static CREATEEGRESSONLYINTERNETGATEWAYINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.ec2.synthetic#CreateEgressOnlyInternetGatewayInput$ClientToken",
   43     43   
        "com.amazonaws.ec2.synthetic",
   44     44   
        "CreateEgressOnlyInternetGatewayInput",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::String,
   47         -
    "client_token",
          47  +
    "ClientToken",
   48     48   
    0,
   49     49   
);
   50     50   
static CREATEEGRESSONLYINTERNETGATEWAYINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.ec2.synthetic#CreateEgressOnlyInternetGatewayInput$DryRun",
   53     53   
        "com.amazonaws.ec2.synthetic",
   54     54   
        "CreateEgressOnlyInternetGatewayInput",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::Boolean,
   57         -
    "dry_run",
          57  +
    "DryRun",
   58     58   
    1,
   59     59   
);
   60     60   
static CREATEEGRESSONLYINTERNETGATEWAYINPUT_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.ec2.synthetic#CreateEgressOnlyInternetGatewayInput$VpcId",
   63     63   
        "com.amazonaws.ec2.synthetic",
   64     64   
        "CreateEgressOnlyInternetGatewayInput",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::String,
   67         -
    "vpc_id",
          67  +
    "VpcId",
   68     68   
    2,
   69     69   
);
   70     70   
static CREATEEGRESSONLYINTERNETGATEWAYINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.ec2.synthetic#CreateEgressOnlyInternetGatewayInput$TagSpecifications",
   73     73   
        "com.amazonaws.ec2.synthetic",
   74     74   
        "CreateEgressOnlyInternetGatewayInput",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::List,
   77         -
    "tag_specifications",
          77  +
    "TagSpecifications",
   78     78   
    3,
   79     79   
)
   80     80   
.with_xml_name("TagSpecification");
   81     81   
static CREATEEGRESSONLYINTERNETGATEWAYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   82     82   
    CREATEEGRESSONLYINTERNETGATEWAYINPUT_SCHEMA_ID,
   83     83   
    ::aws_smithy_schema::ShapeType::Structure,
   84     84   
    &[
   85     85   
        &CREATEEGRESSONLYINTERNETGATEWAYINPUT_MEMBER_CLIENT_TOKEN,
   86     86   
        &CREATEEGRESSONLYINTERNETGATEWAYINPUT_MEMBER_DRY_RUN,
   87     87   
        &CREATEEGRESSONLYINTERNETGATEWAYINPUT_MEMBER_VPC_ID,
   88     88   
        &CREATEEGRESSONLYINTERNETGATEWAYINPUT_MEMBER_TAG_SPECIFICATIONS,
   89     89   
    ],
   90     90   
);
   91     91   
impl CreateEgressOnlyInternetGatewayInput {
   92     92   
    /// The schema for this shape.
   93     93   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEEGRESSONLYINTERNETGATEWAYINPUT_SCHEMA;
   94     94   
}
   95     95   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateEgressOnlyInternetGatewayInput {
   96     96   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   97     97   
    fn serialize_members(
   98     98   
        &self,
   99     99   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  100    100   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  101    101   
        if let Some(ref val) = self.client_token {
  102    102   
            ser.write_string(&CREATEEGRESSONLYINTERNETGATEWAYINPUT_MEMBER_CLIENT_TOKEN, val)?;
  103    103   
        }
  104    104   
        if let Some(ref val) = self.dry_run {
  105    105   
            ser.write_boolean(&CREATEEGRESSONLYINTERNETGATEWAYINPUT_MEMBER_DRY_RUN, *val)?;
  106    106   
        }
  107    107   
        if let Some(ref val) = self.vpc_id {
  108    108   
            ser.write_string(&CREATEEGRESSONLYINTERNETGATEWAYINPUT_MEMBER_VPC_ID, val)?;
  109    109   
        }
  110    110   
        if let Some(ref val) = self.tag_specifications {
  111    111   
            ser.write_list(
  112    112   
                &CREATEEGRESSONLYINTERNETGATEWAYINPUT_MEMBER_TAG_SPECIFICATIONS,
  113    113   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  114    114   
                    for item in val {
  115    115   
                        ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
  116    116   
                    }
  117    117   
                    Ok(())
  118    118   
                },
  119    119   
            )?;
  120    120   
        }
  121    121   
        Ok(())
  122    122   
    }
  123    123   
}
  124    124   
impl CreateEgressOnlyInternetGatewayInput {
  125    125   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  126         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  127         -
        deserializer: &mut D,
         126  +
    pub fn deserialize(
         127  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  128    128   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  129    129   
        #[allow(unused_variables, unused_mut)]
  130    130   
        let mut builder = Self::builder();
  131    131   
        #[allow(
  132    132   
            unused_variables,
  133    133   
            unreachable_code,
  134    134   
            clippy::single_match,
  135    135   
            clippy::match_single_binding,
  136    136   
            clippy::diverging_sub_expression
  137    137   
        )]
  138         -
        deserializer.read_struct(&CREATEEGRESSONLYINTERNETGATEWAYINPUT_SCHEMA, (), |_, member, deser| {
         138  +
        deserializer.read_struct(&CREATEEGRESSONLYINTERNETGATEWAYINPUT_SCHEMA, &mut |member, deser| {
  139    139   
            match member.member_index() {
  140    140   
                Some(0) => {
  141    141   
                    builder.client_token = Some(deser.read_string(member)?);
  142    142   
                }
  143    143   
                Some(1) => {
  144    144   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  145    145   
                }
  146    146   
                Some(2) => {
  147    147   
                    builder.vpc_id = Some(deser.read_string(member)?);
  148    148   
                }
  149    149   
                Some(3) => {
  150    150   
                    builder.tag_specifications = Some({
  151         -
                        let container = if let Some(cap) = deser.container_size() {
  152         -
                            Vec::with_capacity(cap)
  153         -
                        } else {
  154         -
                            Vec::new()
  155         -
                        };
  156         -
                        deser.read_list(member, container, |mut list, deser| {
  157         -
                            list.push(crate::types::TagSpecification::deserialize(deser)?);
  158         -
                            Ok(list)
  159         -
                        })?
         151  +
                        let mut container = Vec::new();
         152  +
                        deser.read_list(member, &mut |deser| {
         153  +
                            container.push(crate::types::TagSpecification::deserialize(deser)?);
         154  +
                            Ok(())
         155  +
                        })?;
         156  +
                        container
  160    157   
                    });
  161    158   
                }
  162    159   
                _ => {}
  163    160   
            }
  164    161   
            Ok(())
  165    162   
        })?;
         163  +
        builder.vpc_id = builder.vpc_id.or(Some(String::new()));
  166    164   
        builder
  167    165   
            .build()
  168    166   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  169    167   
    }
  170    168   
}
         169  +
impl CreateEgressOnlyInternetGatewayInput {
         170  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         171  +
    pub fn deserialize_with_response(
         172  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         173  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         174  +
        _status: u16,
         175  +
        _body: &[u8],
         176  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         177  +
        Self::deserialize(deserializer)
         178  +
    }
         179  +
}
  171    180   
impl CreateEgressOnlyInternetGatewayInput {
  172    181   
    /// Creates a new builder-style object to manufacture [`CreateEgressOnlyInternetGatewayInput`](crate::operation::create_egress_only_internet_gateway::CreateEgressOnlyInternetGatewayInput).
  173    182   
    pub fn builder() -> crate::operation::create_egress_only_internet_gateway::builders::CreateEgressOnlyInternetGatewayInputBuilder {
  174    183   
        crate::operation::create_egress_only_internet_gateway::builders::CreateEgressOnlyInternetGatewayInputBuilder::default()
  175    184   
    }
  176    185   
}
  177    186   
  178    187   
/// A builder for [`CreateEgressOnlyInternetGatewayInput`](crate::operation::create_egress_only_internet_gateway::CreateEgressOnlyInternetGatewayInput).
  179    188   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  180    189   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_egress_only_internet_gateway/_create_egress_only_internet_gateway_output.rs

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