AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_traffic_mirror_target/_create_traffic_mirror_target_input.rs

@@ -35,35 +269,277 @@
   55     55   
    "com.amazonaws.ec2.synthetic",
   56     56   
    "CreateTrafficMirrorTargetInput",
   57     57   
);
   58     58   
static CREATETRAFFICMIRRORTARGETINPUT_MEMBER_NETWORK_INTERFACE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static(
   60     60   
        "com.amazonaws.ec2.synthetic#CreateTrafficMirrorTargetInput$NetworkInterfaceId",
   61     61   
        "com.amazonaws.ec2.synthetic",
   62     62   
        "CreateTrafficMirrorTargetInput",
   63     63   
    ),
   64     64   
    ::aws_smithy_schema::ShapeType::String,
   65         -
    "network_interface_id",
          65  +
    "NetworkInterfaceId",
   66     66   
    0,
   67     67   
);
   68     68   
static CREATETRAFFICMIRRORTARGETINPUT_MEMBER_NETWORK_LOAD_BALANCER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.ec2.synthetic#CreateTrafficMirrorTargetInput$NetworkLoadBalancerArn",
   71     71   
        "com.amazonaws.ec2.synthetic",
   72     72   
        "CreateTrafficMirrorTargetInput",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "network_load_balancer_arn",
          75  +
    "NetworkLoadBalancerArn",
   76     76   
    1,
   77     77   
);
   78     78   
static CREATETRAFFICMIRRORTARGETINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.ec2.synthetic#CreateTrafficMirrorTargetInput$Description",
   81     81   
        "com.amazonaws.ec2.synthetic",
   82     82   
        "CreateTrafficMirrorTargetInput",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::String,
   85         -
    "description",
          85  +
    "Description",
   86     86   
    2,
   87     87   
);
   88     88   
static CREATETRAFFICMIRRORTARGETINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.ec2.synthetic#CreateTrafficMirrorTargetInput$TagSpecifications",
   91     91   
        "com.amazonaws.ec2.synthetic",
   92     92   
        "CreateTrafficMirrorTargetInput",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::List,
   95         -
    "tag_specifications",
          95  +
    "TagSpecifications",
   96     96   
    3,
   97     97   
)
   98     98   
.with_xml_name("TagSpecification");
   99     99   
static CREATETRAFFICMIRRORTARGETINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.ec2.synthetic#CreateTrafficMirrorTargetInput$DryRun",
  102    102   
        "com.amazonaws.ec2.synthetic",
  103    103   
        "CreateTrafficMirrorTargetInput",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::Boolean,
  106         -
    "dry_run",
         106  +
    "DryRun",
  107    107   
    4,
  108    108   
);
  109    109   
static CREATETRAFFICMIRRORTARGETINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.ec2.synthetic#CreateTrafficMirrorTargetInput$ClientToken",
  112    112   
        "com.amazonaws.ec2.synthetic",
  113    113   
        "CreateTrafficMirrorTargetInput",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "client_token",
         116  +
    "ClientToken",
  117    117   
    5,
  118    118   
);
  119    119   
static CREATETRAFFICMIRRORTARGETINPUT_MEMBER_GATEWAY_LOAD_BALANCER_ENDPOINT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.ec2.synthetic#CreateTrafficMirrorTargetInput$GatewayLoadBalancerEndpointId",
  122    122   
        "com.amazonaws.ec2.synthetic",
  123    123   
        "CreateTrafficMirrorTargetInput",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::String,
  126         -
    "gateway_load_balancer_endpoint_id",
         126  +
    "GatewayLoadBalancerEndpointId",
  127    127   
    6,
  128    128   
);
  129    129   
static CREATETRAFFICMIRRORTARGETINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  130    130   
    CREATETRAFFICMIRRORTARGETINPUT_SCHEMA_ID,
  131    131   
    ::aws_smithy_schema::ShapeType::Structure,
  132    132   
    &[
  133    133   
        &CREATETRAFFICMIRRORTARGETINPUT_MEMBER_NETWORK_INTERFACE_ID,
  134    134   
        &CREATETRAFFICMIRRORTARGETINPUT_MEMBER_NETWORK_LOAD_BALANCER_ARN,
  135    135   
        &CREATETRAFFICMIRRORTARGETINPUT_MEMBER_DESCRIPTION,
  136    136   
        &CREATETRAFFICMIRRORTARGETINPUT_MEMBER_TAG_SPECIFICATIONS,
  137    137   
        &CREATETRAFFICMIRRORTARGETINPUT_MEMBER_DRY_RUN,
  138    138   
        &CREATETRAFFICMIRRORTARGETINPUT_MEMBER_CLIENT_TOKEN,
  139    139   
        &CREATETRAFFICMIRRORTARGETINPUT_MEMBER_GATEWAY_LOAD_BALANCER_ENDPOINT_ID,
  140    140   
    ],
  141    141   
);
  142    142   
impl CreateTrafficMirrorTargetInput {
  143    143   
    /// The schema for this shape.
  144    144   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATETRAFFICMIRRORTARGETINPUT_SCHEMA;
  145    145   
}
  146    146   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateTrafficMirrorTargetInput {
  147    147   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  148    148   
    fn serialize_members(
  149    149   
        &self,
  150    150   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  151    151   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  152    152   
        if let Some(ref val) = self.network_interface_id {
  153    153   
            ser.write_string(&CREATETRAFFICMIRRORTARGETINPUT_MEMBER_NETWORK_INTERFACE_ID, val)?;
  154    154   
        }
  155    155   
        if let Some(ref val) = self.network_load_balancer_arn {
  156    156   
            ser.write_string(&CREATETRAFFICMIRRORTARGETINPUT_MEMBER_NETWORK_LOAD_BALANCER_ARN, val)?;
  157    157   
        }
  158    158   
        if let Some(ref val) = self.description {
  159    159   
            ser.write_string(&CREATETRAFFICMIRRORTARGETINPUT_MEMBER_DESCRIPTION, val)?;
  160    160   
        }
  161    161   
        if let Some(ref val) = self.tag_specifications {
  162    162   
            ser.write_list(
  163    163   
                &CREATETRAFFICMIRRORTARGETINPUT_MEMBER_TAG_SPECIFICATIONS,
  164    164   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  165    165   
                    for item in val {
  166    166   
                        ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
  167    167   
                    }
  168    168   
                    Ok(())
  169    169   
                },
  170    170   
            )?;
  171    171   
        }
  172    172   
        if let Some(ref val) = self.dry_run {
  173    173   
            ser.write_boolean(&CREATETRAFFICMIRRORTARGETINPUT_MEMBER_DRY_RUN, *val)?;
  174    174   
        }
  175    175   
        if let Some(ref val) = self.client_token {
  176    176   
            ser.write_string(&CREATETRAFFICMIRRORTARGETINPUT_MEMBER_CLIENT_TOKEN, val)?;
  177    177   
        }
  178    178   
        if let Some(ref val) = self.gateway_load_balancer_endpoint_id {
  179    179   
            ser.write_string(&CREATETRAFFICMIRRORTARGETINPUT_MEMBER_GATEWAY_LOAD_BALANCER_ENDPOINT_ID, val)?;
  180    180   
        }
  181    181   
        Ok(())
  182    182   
    }
  183    183   
}
  184    184   
impl CreateTrafficMirrorTargetInput {
  185    185   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  186         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  187         -
        deserializer: &mut D,
         186  +
    pub fn deserialize(
         187  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  188    188   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  189    189   
        #[allow(unused_variables, unused_mut)]
  190    190   
        let mut builder = Self::builder();
  191    191   
        #[allow(
  192    192   
            unused_variables,
  193    193   
            unreachable_code,
  194    194   
            clippy::single_match,
  195    195   
            clippy::match_single_binding,
  196    196   
            clippy::diverging_sub_expression
  197    197   
        )]
  198         -
        deserializer.read_struct(&CREATETRAFFICMIRRORTARGETINPUT_SCHEMA, (), |_, member, deser| {
         198  +
        deserializer.read_struct(&CREATETRAFFICMIRRORTARGETINPUT_SCHEMA, &mut |member, deser| {
  199    199   
            match member.member_index() {
  200    200   
                Some(0) => {
  201    201   
                    builder.network_interface_id = Some(deser.read_string(member)?);
  202    202   
                }
  203    203   
                Some(1) => {
  204    204   
                    builder.network_load_balancer_arn = Some(deser.read_string(member)?);
  205    205   
                }
  206    206   
                Some(2) => {
  207    207   
                    builder.description = Some(deser.read_string(member)?);
  208    208   
                }
  209    209   
                Some(3) => {
  210    210   
                    builder.tag_specifications = Some({
  211         -
                        let container = if let Some(cap) = deser.container_size() {
  212         -
                            Vec::with_capacity(cap)
  213         -
                        } else {
  214         -
                            Vec::new()
  215         -
                        };
  216         -
                        deser.read_list(member, container, |mut list, deser| {
  217         -
                            list.push(crate::types::TagSpecification::deserialize(deser)?);
  218         -
                            Ok(list)
  219         -
                        })?
         211  +
                        let mut container = Vec::new();
         212  +
                        deser.read_list(member, &mut |deser| {
         213  +
                            container.push(crate::types::TagSpecification::deserialize(deser)?);
         214  +
                            Ok(())
         215  +
                        })?;
         216  +
                        container
  220    217   
                    });
  221    218   
                }
  222    219   
                Some(4) => {
  223    220   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  224    221   
                }
  225    222   
                Some(5) => {
  226    223   
                    builder.client_token = Some(deser.read_string(member)?);
  227    224   
                }
  228    225   
                Some(6) => {
  229    226   
                    builder.gateway_load_balancer_endpoint_id = Some(deser.read_string(member)?);
  230    227   
                }
  231    228   
                _ => {}
  232    229   
            }
  233    230   
            Ok(())
  234    231   
        })?;
  235    232   
        builder
  236    233   
            .build()
  237    234   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  238    235   
    }
  239    236   
}
         237  +
impl CreateTrafficMirrorTargetInput {
         238  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         239  +
    pub fn deserialize_with_response(
         240  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         241  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         242  +
        _status: u16,
         243  +
        _body: &[u8],
         244  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         245  +
        Self::deserialize(deserializer)
         246  +
    }
         247  +
}
  240    248   
impl CreateTrafficMirrorTargetInput {
  241    249   
    /// Creates a new builder-style object to manufacture [`CreateTrafficMirrorTargetInput`](crate::operation::create_traffic_mirror_target::CreateTrafficMirrorTargetInput).
  242    250   
    pub fn builder() -> crate::operation::create_traffic_mirror_target::builders::CreateTrafficMirrorTargetInputBuilder {
  243    251   
        crate::operation::create_traffic_mirror_target::builders::CreateTrafficMirrorTargetInputBuilder::default()
  244    252   
    }
  245    253   
}
  246    254   
  247    255   
/// A builder for [`CreateTrafficMirrorTargetInput`](crate::operation::create_traffic_mirror_target::CreateTrafficMirrorTargetInput).
  248    256   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  249    257   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_traffic_mirror_target/_create_traffic_mirror_target_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_transit_gateway/_create_transit_gateway_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_transit_gateway/_create_transit_gateway_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_transit_gateway_connect/_create_transit_gateway_connect_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_transit_gateway_connect/_create_transit_gateway_connect_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_transit_gateway_connect_peer.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 `CreateTransitGatewayConnectPeer`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CreateTransitGatewayConnectPeer;
    6      6   
impl CreateTransitGatewayConnectPeer {
    7      7   
    /// Creates a new `CreateTransitGatewayConnectPeer`
    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_transit_gateway_connect_peer::CreateTransitGatewayConnectPeerInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::create_transit_gateway_connect_peer::CreateTransitGatewayConnectPeerOutput::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_transit_gateway_connect_peer::CreateTransitGatewayConnectPeerInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::create_transit_gateway_connect_peer::CreateTransitGatewayConnectPeerOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::create_transit_gateway_connect_peer::CreateTransitGatewayConnectPeerError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +186,193 @@
  144    150   
                crate::operation::create_transit_gateway_connect_peer::CreateTransitGatewayConnectPeerError,
  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 CreateTransitGatewayConnectPeerResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateTransitGatewayConnectPeerResponseDeserializer {
  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_transit_gateway_connect_peer::de_create_transit_gateway_connect_peer_http_error(status, headers, body)
  166    173   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_transit_gateway_connect_peer/_create_transit_gateway_connect_peer_input.rs

@@ -38,38 +159,159 @@
   58     58   
    "CreateTransitGatewayConnectPeerInput",
   59     59   
);
   60     60   
static CREATETRANSITGATEWAYCONNECTPEERINPUT_MEMBER_TRANSIT_GATEWAY_ATTACHMENT_ID: ::aws_smithy_schema::Schema =
   61     61   
    ::aws_smithy_schema::Schema::new_member(
   62     62   
        ::aws_smithy_schema::ShapeId::from_static(
   63     63   
            "com.amazonaws.ec2.synthetic#CreateTransitGatewayConnectPeerInput$TransitGatewayAttachmentId",
   64     64   
            "com.amazonaws.ec2.synthetic",
   65     65   
            "CreateTransitGatewayConnectPeerInput",
   66     66   
        ),
   67     67   
        ::aws_smithy_schema::ShapeType::String,
   68         -
        "transit_gateway_attachment_id",
          68  +
        "TransitGatewayAttachmentId",
   69     69   
        0,
   70     70   
    );
   71     71   
static CREATETRANSITGATEWAYCONNECTPEERINPUT_MEMBER_TRANSIT_GATEWAY_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayConnectPeerInput$TransitGatewayAddress",
   74     74   
        "com.amazonaws.ec2.synthetic",
   75     75   
        "CreateTransitGatewayConnectPeerInput",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::String,
   78         -
    "transit_gateway_address",
          78  +
    "TransitGatewayAddress",
   79     79   
    1,
   80     80   
);
   81     81   
static CREATETRANSITGATEWAYCONNECTPEERINPUT_MEMBER_PEER_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayConnectPeerInput$PeerAddress",
   84     84   
        "com.amazonaws.ec2.synthetic",
   85     85   
        "CreateTransitGatewayConnectPeerInput",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::String,
   88         -
    "peer_address",
          88  +
    "PeerAddress",
   89     89   
    2,
   90     90   
);
   91     91   
static CREATETRANSITGATEWAYCONNECTPEERINPUT_MEMBER_BGP_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayConnectPeerInput$BgpOptions",
   94     94   
        "com.amazonaws.ec2.synthetic",
   95     95   
        "CreateTransitGatewayConnectPeerInput",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::Structure,
   98         -
    "bgp_options",
          98  +
    "BgpOptions",
   99     99   
    3,
  100    100   
);
  101    101   
static CREATETRANSITGATEWAYCONNECTPEERINPUT_MEMBER_INSIDE_CIDR_BLOCKS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayConnectPeerInput$InsideCidrBlocks",
  104    104   
        "com.amazonaws.ec2.synthetic",
  105    105   
        "CreateTransitGatewayConnectPeerInput",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::List,
  108         -
    "inside_cidr_blocks",
         108  +
    "InsideCidrBlocks",
  109    109   
    4,
  110    110   
);
  111    111   
static CREATETRANSITGATEWAYCONNECTPEERINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static(
  113    113   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayConnectPeerInput$TagSpecifications",
  114    114   
        "com.amazonaws.ec2.synthetic",
  115    115   
        "CreateTransitGatewayConnectPeerInput",
  116    116   
    ),
  117    117   
    ::aws_smithy_schema::ShapeType::List,
  118         -
    "tag_specifications",
         118  +
    "TagSpecifications",
  119    119   
    5,
  120    120   
)
  121    121   
.with_xml_name("TagSpecification");
  122    122   
static CREATETRANSITGATEWAYCONNECTPEERINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  123    123   
    ::aws_smithy_schema::ShapeId::from_static(
  124    124   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayConnectPeerInput$DryRun",
  125    125   
        "com.amazonaws.ec2.synthetic",
  126    126   
        "CreateTransitGatewayConnectPeerInput",
  127    127   
    ),
  128    128   
    ::aws_smithy_schema::ShapeType::Boolean,
  129         -
    "dry_run",
         129  +
    "DryRun",
  130    130   
    6,
  131    131   
);
  132    132   
static CREATETRANSITGATEWAYCONNECTPEERINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  133    133   
    CREATETRANSITGATEWAYCONNECTPEERINPUT_SCHEMA_ID,
  134    134   
    ::aws_smithy_schema::ShapeType::Structure,
  135    135   
    &[
  136    136   
        &CREATETRANSITGATEWAYCONNECTPEERINPUT_MEMBER_TRANSIT_GATEWAY_ATTACHMENT_ID,
  137    137   
        &CREATETRANSITGATEWAYCONNECTPEERINPUT_MEMBER_TRANSIT_GATEWAY_ADDRESS,
  138    138   
        &CREATETRANSITGATEWAYCONNECTPEERINPUT_MEMBER_PEER_ADDRESS,
  139    139   
        &CREATETRANSITGATEWAYCONNECTPEERINPUT_MEMBER_BGP_OPTIONS,
@@ -167,167 +290,291 @@
  187    187   
            )?;
  188    188   
        }
  189    189   
        if let Some(ref val) = self.dry_run {
  190    190   
            ser.write_boolean(&CREATETRANSITGATEWAYCONNECTPEERINPUT_MEMBER_DRY_RUN, *val)?;
  191    191   
        }
  192    192   
        Ok(())
  193    193   
    }
  194    194   
}
  195    195   
impl CreateTransitGatewayConnectPeerInput {
  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(&CREATETRANSITGATEWAYCONNECTPEERINPUT_SCHEMA, (), |_, member, deser| {
         209  +
        deserializer.read_struct(&CREATETRANSITGATEWAYCONNECTPEERINPUT_SCHEMA, &mut |member, deser| {
  210    210   
            match member.member_index() {
  211    211   
                Some(0) => {
  212    212   
                    builder.transit_gateway_attachment_id = Some(deser.read_string(member)?);
  213    213   
                }
  214    214   
                Some(1) => {
  215    215   
                    builder.transit_gateway_address = Some(deser.read_string(member)?);
  216    216   
                }
  217    217   
                Some(2) => {
  218    218   
                    builder.peer_address = Some(deser.read_string(member)?);
  219    219   
                }
  220    220   
                Some(3) => {
  221    221   
                    builder.bgp_options = Some(crate::types::TransitGatewayConnectRequestBgpOptions::deserialize(deser)?);
  222    222   
                }
  223    223   
                Some(4) => {
  224         -
                    builder.inside_cidr_blocks = 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(deser.read_string(member)?);
  232         -
                            Ok(list)
  233         -
                        })?
  234         -
                    });
         224  +
                    builder.inside_cidr_blocks = Some(deser.read_string_list(member)?);
  235    225   
                }
  236    226   
                Some(5) => {
  237    227   
                    builder.tag_specifications = Some({
  238         -
                        let container = if let Some(cap) = deser.container_size() {
  239         -
                            Vec::with_capacity(cap)
  240         -
                        } else {
  241         -
                            Vec::new()
  242         -
                        };
  243         -
                        deser.read_list(member, container, |mut list, deser| {
  244         -
                            list.push(crate::types::TagSpecification::deserialize(deser)?);
  245         -
                            Ok(list)
  246         -
                        })?
         228  +
                        let mut container = Vec::new();
         229  +
                        deser.read_list(member, &mut |deser| {
         230  +
                            container.push(crate::types::TagSpecification::deserialize(deser)?);
         231  +
                            Ok(())
         232  +
                        })?;
         233  +
                        container
  247    234   
                    });
  248    235   
                }
  249    236   
                Some(6) => {
  250    237   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  251    238   
                }
  252    239   
                _ => {}
  253    240   
            }
  254    241   
            Ok(())
  255    242   
        })?;
         243  +
        builder.transit_gateway_attachment_id = builder.transit_gateway_attachment_id.or(Some(String::new()));
         244  +
        builder.peer_address = builder.peer_address.or(Some(String::new()));
         245  +
        builder.inside_cidr_blocks = builder.inside_cidr_blocks.or(Some(Vec::new()));
  256    246   
        builder
  257    247   
            .build()
  258    248   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  259    249   
    }
  260    250   
}
         251  +
impl CreateTransitGatewayConnectPeerInput {
         252  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         253  +
    pub fn deserialize_with_response(
         254  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         255  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         256  +
        _status: u16,
         257  +
        _body: &[u8],
         258  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         259  +
        Self::deserialize(deserializer)
         260  +
    }
         261  +
}
  261    262   
impl CreateTransitGatewayConnectPeerInput {
  262    263   
    /// Creates a new builder-style object to manufacture [`CreateTransitGatewayConnectPeerInput`](crate::operation::create_transit_gateway_connect_peer::CreateTransitGatewayConnectPeerInput).
  263    264   
    pub fn builder() -> crate::operation::create_transit_gateway_connect_peer::builders::CreateTransitGatewayConnectPeerInputBuilder {
  264    265   
        crate::operation::create_transit_gateway_connect_peer::builders::CreateTransitGatewayConnectPeerInputBuilder::default()
  265    266   
    }
  266    267   
}
  267    268   
  268    269   
/// A builder for [`CreateTransitGatewayConnectPeerInput`](crate::operation::create_transit_gateway_connect_peer::CreateTransitGatewayConnectPeerInput).
  269    270   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  270    271   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_transit_gateway_connect_peer/_create_transit_gateway_connect_peer_output.rs

@@ -1,1 +98,145 @@
   19     19   
    "CreateTransitGatewayConnectPeerOutput",
   20     20   
);
   21     21   
static CREATETRANSITGATEWAYCONNECTPEEROUTPUT_MEMBER_TRANSIT_GATEWAY_CONNECT_PEER: ::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#CreateTransitGatewayConnectPeerOutput$TransitGatewayConnectPeer",
   25     25   
            "com.amazonaws.ec2.synthetic",
   26     26   
            "CreateTransitGatewayConnectPeerOutput",
   27     27   
        ),
   28     28   
        ::aws_smithy_schema::ShapeType::Structure,
   29         -
        "transit_gateway_connect_peer",
          29  +
        "TransitGatewayConnectPeer",
   30     30   
        0,
   31     31   
    )
   32     32   
    .with_xml_name("transitGatewayConnectPeer");
          33  +
static CREATETRANSITGATEWAYCONNECTPEEROUTPUT_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 CREATETRANSITGATEWAYCONNECTPEEROUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     41   
    CREATETRANSITGATEWAYCONNECTPEEROUTPUT_SCHEMA_ID,
   35     42   
    ::aws_smithy_schema::ShapeType::Structure,
   36         -
    &[&CREATETRANSITGATEWAYCONNECTPEEROUTPUT_MEMBER_TRANSIT_GATEWAY_CONNECT_PEER],
          43  +
    &[
          44  +
        &CREATETRANSITGATEWAYCONNECTPEEROUTPUT_MEMBER_TRANSIT_GATEWAY_CONNECT_PEER,
          45  +
        &CREATETRANSITGATEWAYCONNECTPEEROUTPUT_MEMBER__REQUEST_ID,
          46  +
    ],
   37     47   
);
   38     48   
impl CreateTransitGatewayConnectPeerOutput {
   39     49   
    /// The schema for this shape.
   40     50   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATETRANSITGATEWAYCONNECTPEEROUTPUT_SCHEMA;
   41     51   
}
   42     52   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateTransitGatewayConnectPeerOutput {
   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.transit_gateway_connect_peer {
   49     59   
            ser.write_struct(&CREATETRANSITGATEWAYCONNECTPEEROUTPUT_MEMBER_TRANSIT_GATEWAY_CONNECT_PEER, val)?;
   50     60   
        }
   51     61   
        Ok(())
   52     62   
    }
   53     63   
}
   54     64   
impl CreateTransitGatewayConnectPeerOutput {
   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(&CREATETRANSITGATEWAYCONNECTPEEROUTPUT_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&CREATETRANSITGATEWAYCONNECTPEEROUTPUT_SCHEMA, &mut |member, deser| {
          79  +
            match member.member_index() {
          80  +
                Some(0) => {
          81  +
                    builder.transit_gateway_connect_peer = Some(crate::types::TransitGatewayConnectPeer::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 CreateTransitGatewayConnectPeerOutput {
          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(&CREATETRANSITGATEWAYCONNECTPEEROUTPUT_SCHEMA, &mut |member, deser| {
   69    116   
            match member.member_index() {
   70    117   
                Some(0) => {
   71    118   
                    builder.transit_gateway_connect_peer = Some(crate::types::TransitGatewayConnectPeer::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_transit_gateway_multicast_domain.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 `CreateTransitGatewayMulticastDomain`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CreateTransitGatewayMulticastDomain;
    6      6   
impl CreateTransitGatewayMulticastDomain {
    7      7   
    /// Creates a new `CreateTransitGatewayMulticastDomain`
    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_transit_gateway_multicast_domain::CreateTransitGatewayMulticastDomainInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::create_transit_gateway_multicast_domain::CreateTransitGatewayMulticastDomainOutput::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_transit_gateway_multicast_domain::CreateTransitGatewayMulticastDomainInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::create_transit_gateway_multicast_domain::CreateTransitGatewayMulticastDomainOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::create_transit_gateway_multicast_domain::CreateTransitGatewayMulticastDomainError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +186,193 @@
  144    150   
                crate::operation::create_transit_gateway_multicast_domain::CreateTransitGatewayMulticastDomainError,
  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 CreateTransitGatewayMulticastDomainResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateTransitGatewayMulticastDomainResponseDeserializer {
  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_transit_gateway_multicast_domain::de_create_transit_gateway_multicast_domain_http_error(
  166    173   
                status, headers, body,

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_transit_gateway_multicast_domain/_create_transit_gateway_multicast_domain_input.rs

@@ -17,17 +200,209 @@
   37     37   
    "com.amazonaws.ec2.synthetic",
   38     38   
    "CreateTransitGatewayMulticastDomainInput",
   39     39   
);
   40     40   
static CREATETRANSITGATEWAYMULTICASTDOMAININPUT_MEMBER_TRANSIT_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayMulticastDomainInput$TransitGatewayId",
   43     43   
        "com.amazonaws.ec2.synthetic",
   44     44   
        "CreateTransitGatewayMulticastDomainInput",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::String,
   47         -
    "transit_gateway_id",
          47  +
    "TransitGatewayId",
   48     48   
    0,
   49     49   
);
   50     50   
static CREATETRANSITGATEWAYMULTICASTDOMAININPUT_MEMBER_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayMulticastDomainInput$Options",
   53     53   
        "com.amazonaws.ec2.synthetic",
   54     54   
        "CreateTransitGatewayMulticastDomainInput",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::Structure,
   57         -
    "options",
          57  +
    "Options",
   58     58   
    1,
   59     59   
);
   60     60   
static CREATETRANSITGATEWAYMULTICASTDOMAININPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayMulticastDomainInput$TagSpecifications",
   63     63   
        "com.amazonaws.ec2.synthetic",
   64     64   
        "CreateTransitGatewayMulticastDomainInput",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::List,
   67         -
    "tag_specifications",
          67  +
    "TagSpecifications",
   68     68   
    2,
   69     69   
)
   70     70   
.with_xml_name("TagSpecification");
   71     71   
static CREATETRANSITGATEWAYMULTICASTDOMAININPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayMulticastDomainInput$DryRun",
   74     74   
        "com.amazonaws.ec2.synthetic",
   75     75   
        "CreateTransitGatewayMulticastDomainInput",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::Boolean,
   78         -
    "dry_run",
          78  +
    "DryRun",
   79     79   
    3,
   80     80   
);
   81     81   
static CREATETRANSITGATEWAYMULTICASTDOMAININPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   82     82   
    CREATETRANSITGATEWAYMULTICASTDOMAININPUT_SCHEMA_ID,
   83     83   
    ::aws_smithy_schema::ShapeType::Structure,
   84     84   
    &[
   85     85   
        &CREATETRANSITGATEWAYMULTICASTDOMAININPUT_MEMBER_TRANSIT_GATEWAY_ID,
   86     86   
        &CREATETRANSITGATEWAYMULTICASTDOMAININPUT_MEMBER_OPTIONS,
   87     87   
        &CREATETRANSITGATEWAYMULTICASTDOMAININPUT_MEMBER_TAG_SPECIFICATIONS,
   88     88   
        &CREATETRANSITGATEWAYMULTICASTDOMAININPUT_MEMBER_DRY_RUN,
   89     89   
    ],
   90     90   
);
   91     91   
impl CreateTransitGatewayMulticastDomainInput {
   92     92   
    /// The schema for this shape.
   93     93   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATETRANSITGATEWAYMULTICASTDOMAININPUT_SCHEMA;
   94     94   
}
   95     95   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateTransitGatewayMulticastDomainInput {
   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.transit_gateway_id {
  102    102   
            ser.write_string(&CREATETRANSITGATEWAYMULTICASTDOMAININPUT_MEMBER_TRANSIT_GATEWAY_ID, val)?;
  103    103   
        }
  104    104   
        if let Some(ref val) = self.options {
  105    105   
            ser.write_struct(&CREATETRANSITGATEWAYMULTICASTDOMAININPUT_MEMBER_OPTIONS, val)?;
  106    106   
        }
  107    107   
        if let Some(ref val) = self.tag_specifications {
  108    108   
            ser.write_list(
  109    109   
                &CREATETRANSITGATEWAYMULTICASTDOMAININPUT_MEMBER_TAG_SPECIFICATIONS,
  110    110   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  111    111   
                    for item in val {
  112    112   
                        ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
  113    113   
                    }
  114    114   
                    Ok(())
  115    115   
                },
  116    116   
            )?;
  117    117   
        }
  118    118   
        if let Some(ref val) = self.dry_run {
  119    119   
            ser.write_boolean(&CREATETRANSITGATEWAYMULTICASTDOMAININPUT_MEMBER_DRY_RUN, *val)?;
  120    120   
        }
  121    121   
        Ok(())
  122    122   
    }
  123    123   
}
  124    124   
impl CreateTransitGatewayMulticastDomainInput {
  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(&CREATETRANSITGATEWAYMULTICASTDOMAININPUT_SCHEMA, (), |_, member, deser| {
         138  +
        deserializer.read_struct(&CREATETRANSITGATEWAYMULTICASTDOMAININPUT_SCHEMA, &mut |member, deser| {
  139    139   
            match member.member_index() {
  140    140   
                Some(0) => {
  141    141   
                    builder.transit_gateway_id = Some(deser.read_string(member)?);
  142    142   
                }
  143    143   
                Some(1) => {
  144    144   
                    builder.options = Some(crate::types::CreateTransitGatewayMulticastDomainRequestOptions::deserialize(deser)?);
  145    145   
                }
  146    146   
                Some(2) => {
  147    147   
                    builder.tag_specifications = Some({
  148         -
                        let container = if let Some(cap) = deser.container_size() {
  149         -
                            Vec::with_capacity(cap)
  150         -
                        } else {
  151         -
                            Vec::new()
  152         -
                        };
  153         -
                        deser.read_list(member, container, |mut list, deser| {
  154         -
                            list.push(crate::types::TagSpecification::deserialize(deser)?);
  155         -
                            Ok(list)
  156         -
                        })?
         148  +
                        let mut container = Vec::new();
         149  +
                        deser.read_list(member, &mut |deser| {
         150  +
                            container.push(crate::types::TagSpecification::deserialize(deser)?);
         151  +
                            Ok(())
         152  +
                        })?;
         153  +
                        container
  157    154   
                    });
  158    155   
                }
  159    156   
                Some(3) => {
  160    157   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  161    158   
                }
  162    159   
                _ => {}
  163    160   
            }
  164    161   
            Ok(())
  165    162   
        })?;
         163  +
        builder.transit_gateway_id = builder.transit_gateway_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 CreateTransitGatewayMulticastDomainInput {
         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 CreateTransitGatewayMulticastDomainInput {
  172    181   
    /// Creates a new builder-style object to manufacture [`CreateTransitGatewayMulticastDomainInput`](crate::operation::create_transit_gateway_multicast_domain::CreateTransitGatewayMulticastDomainInput).
  173    182   
    pub fn builder() -> crate::operation::create_transit_gateway_multicast_domain::builders::CreateTransitGatewayMulticastDomainInputBuilder {
  174    183   
        crate::operation::create_transit_gateway_multicast_domain::builders::CreateTransitGatewayMulticastDomainInputBuilder::default()
  175    184   
    }
  176    185   
}
  177    186   
  178    187   
/// A builder for [`CreateTransitGatewayMulticastDomainInput`](crate::operation::create_transit_gateway_multicast_domain::CreateTransitGatewayMulticastDomainInput).
  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_transit_gateway_multicast_domain/_create_transit_gateway_multicast_domain_output.rs

@@ -1,1 +98,145 @@
   19     19   
    "CreateTransitGatewayMulticastDomainOutput",
   20     20   
);
   21     21   
static CREATETRANSITGATEWAYMULTICASTDOMAINOUTPUT_MEMBER_TRANSIT_GATEWAY_MULTICAST_DOMAIN: ::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#CreateTransitGatewayMulticastDomainOutput$TransitGatewayMulticastDomain",
   25     25   
            "com.amazonaws.ec2.synthetic",
   26     26   
            "CreateTransitGatewayMulticastDomainOutput",
   27     27   
        ),
   28     28   
        ::aws_smithy_schema::ShapeType::Structure,
   29         -
        "transit_gateway_multicast_domain",
          29  +
        "TransitGatewayMulticastDomain",
   30     30   
        0,
   31     31   
    )
   32     32   
    .with_xml_name("transitGatewayMulticastDomain");
          33  +
static CREATETRANSITGATEWAYMULTICASTDOMAINOUTPUT_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 CREATETRANSITGATEWAYMULTICASTDOMAINOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     41   
    CREATETRANSITGATEWAYMULTICASTDOMAINOUTPUT_SCHEMA_ID,
   35     42   
    ::aws_smithy_schema::ShapeType::Structure,
   36         -
    &[&CREATETRANSITGATEWAYMULTICASTDOMAINOUTPUT_MEMBER_TRANSIT_GATEWAY_MULTICAST_DOMAIN],
          43  +
    &[
          44  +
        &CREATETRANSITGATEWAYMULTICASTDOMAINOUTPUT_MEMBER_TRANSIT_GATEWAY_MULTICAST_DOMAIN,
          45  +
        &CREATETRANSITGATEWAYMULTICASTDOMAINOUTPUT_MEMBER__REQUEST_ID,
          46  +
    ],
   37     47   
);
   38     48   
impl CreateTransitGatewayMulticastDomainOutput {
   39     49   
    /// The schema for this shape.
   40     50   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATETRANSITGATEWAYMULTICASTDOMAINOUTPUT_SCHEMA;
   41     51   
}
   42     52   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateTransitGatewayMulticastDomainOutput {
   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.transit_gateway_multicast_domain {
   49     59   
            ser.write_struct(&CREATETRANSITGATEWAYMULTICASTDOMAINOUTPUT_MEMBER_TRANSIT_GATEWAY_MULTICAST_DOMAIN, val)?;
   50     60   
        }
   51     61   
        Ok(())
   52     62   
    }
   53     63   
}
   54     64   
impl CreateTransitGatewayMulticastDomainOutput {
   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(&CREATETRANSITGATEWAYMULTICASTDOMAINOUTPUT_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&CREATETRANSITGATEWAYMULTICASTDOMAINOUTPUT_SCHEMA, &mut |member, deser| {
          79  +
            match member.member_index() {
          80  +
                Some(0) => {
          81  +
                    builder.transit_gateway_multicast_domain = Some(crate::types::TransitGatewayMulticastDomain::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 CreateTransitGatewayMulticastDomainOutput {
          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(&CREATETRANSITGATEWAYMULTICASTDOMAINOUTPUT_SCHEMA, &mut |member, deser| {
   69    116   
            match member.member_index() {
   70    117   
                Some(0) => {
   71    118   
                    builder.transit_gateway_multicast_domain = Some(crate::types::TransitGatewayMulticastDomain::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_transit_gateway_peering_attachment.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 `CreateTransitGatewayPeeringAttachment`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CreateTransitGatewayPeeringAttachment;
    6      6   
impl CreateTransitGatewayPeeringAttachment {
    7      7   
    /// Creates a new `CreateTransitGatewayPeeringAttachment`
    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_transit_gateway_peering_attachment::CreateTransitGatewayPeeringAttachmentInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::create_transit_gateway_peering_attachment::CreateTransitGatewayPeeringAttachmentOutput::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_transit_gateway_peering_attachment::CreateTransitGatewayPeeringAttachmentInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::create_transit_gateway_peering_attachment::CreateTransitGatewayPeeringAttachmentOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::create_transit_gateway_peering_attachment::CreateTransitGatewayPeeringAttachmentError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +186,193 @@
  144    150   
                crate::operation::create_transit_gateway_peering_attachment::CreateTransitGatewayPeeringAttachmentError,
  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 CreateTransitGatewayPeeringAttachmentResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateTransitGatewayPeeringAttachmentResponseDeserializer {
  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_transit_gateway_peering_attachment::de_create_transit_gateway_peering_attachment_http_error(
  166    173   
                status, headers, body,

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_transit_gateway_peering_attachment/_create_transit_gateway_peering_attachment_input.rs

@@ -35,35 +270,282 @@
   55     55   
    "com.amazonaws.ec2.synthetic",
   56     56   
    "CreateTransitGatewayPeeringAttachmentInput",
   57     57   
);
   58     58   
static CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_TRANSIT_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static(
   60     60   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayPeeringAttachmentInput$TransitGatewayId",
   61     61   
        "com.amazonaws.ec2.synthetic",
   62     62   
        "CreateTransitGatewayPeeringAttachmentInput",
   63     63   
    ),
   64     64   
    ::aws_smithy_schema::ShapeType::String,
   65         -
    "transit_gateway_id",
          65  +
    "TransitGatewayId",
   66     66   
    0,
   67     67   
);
   68     68   
static CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_PEER_TRANSIT_GATEWAY_ID: ::aws_smithy_schema::Schema =
   69     69   
    ::aws_smithy_schema::Schema::new_member(
   70     70   
        ::aws_smithy_schema::ShapeId::from_static(
   71     71   
            "com.amazonaws.ec2.synthetic#CreateTransitGatewayPeeringAttachmentInput$PeerTransitGatewayId",
   72     72   
            "com.amazonaws.ec2.synthetic",
   73     73   
            "CreateTransitGatewayPeeringAttachmentInput",
   74     74   
        ),
   75     75   
        ::aws_smithy_schema::ShapeType::String,
   76         -
        "peer_transit_gateway_id",
          76  +
        "PeerTransitGatewayId",
   77     77   
        1,
   78     78   
    );
   79     79   
static CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_PEER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayPeeringAttachmentInput$PeerAccountId",
   82     82   
        "com.amazonaws.ec2.synthetic",
   83     83   
        "CreateTransitGatewayPeeringAttachmentInput",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86         -
    "peer_account_id",
          86  +
    "PeerAccountId",
   87     87   
    2,
   88     88   
);
   89     89   
static CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_PEER_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayPeeringAttachmentInput$PeerRegion",
   92     92   
        "com.amazonaws.ec2.synthetic",
   93     93   
        "CreateTransitGatewayPeeringAttachmentInput",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::String,
   96         -
    "peer_region",
          96  +
    "PeerRegion",
   97     97   
    3,
   98     98   
);
   99     99   
static CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayPeeringAttachmentInput$Options",
  102    102   
        "com.amazonaws.ec2.synthetic",
  103    103   
        "CreateTransitGatewayPeeringAttachmentInput",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::Structure,
  106         -
    "options",
         106  +
    "Options",
  107    107   
    4,
  108    108   
);
  109    109   
static CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayPeeringAttachmentInput$TagSpecifications",
  112    112   
        "com.amazonaws.ec2.synthetic",
  113    113   
        "CreateTransitGatewayPeeringAttachmentInput",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::List,
  116         -
    "tag_specifications",
         116  +
    "TagSpecifications",
  117    117   
    5,
  118    118   
)
  119    119   
.with_xml_name("TagSpecification");
  120    120   
static CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  121    121   
    ::aws_smithy_schema::ShapeId::from_static(
  122    122   
        "com.amazonaws.ec2.synthetic#CreateTransitGatewayPeeringAttachmentInput$DryRun",
  123    123   
        "com.amazonaws.ec2.synthetic",
  124    124   
        "CreateTransitGatewayPeeringAttachmentInput",
  125    125   
    ),
  126    126   
    ::aws_smithy_schema::ShapeType::Boolean,
  127         -
    "dry_run",
         127  +
    "DryRun",
  128    128   
    6,
  129    129   
);
  130    130   
static CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  131    131   
    CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_SCHEMA_ID,
  132    132   
    ::aws_smithy_schema::ShapeType::Structure,
  133    133   
    &[
  134    134   
        &CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_TRANSIT_GATEWAY_ID,
  135    135   
        &CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_PEER_TRANSIT_GATEWAY_ID,
  136    136   
        &CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_PEER_ACCOUNT_ID,
  137    137   
        &CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_PEER_REGION,
  138    138   
        &CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_OPTIONS,
  139    139   
        &CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_TAG_SPECIFICATIONS,
  140    140   
        &CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_DRY_RUN,
  141    141   
    ],
  142    142   
);
  143    143   
impl CreateTransitGatewayPeeringAttachmentInput {
  144    144   
    /// The schema for this shape.
  145    145   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_SCHEMA;
  146    146   
}
  147    147   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateTransitGatewayPeeringAttachmentInput {
  148    148   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  149    149   
    fn serialize_members(
  150    150   
        &self,
  151    151   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  152    152   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  153    153   
        if let Some(ref val) = self.transit_gateway_id {
  154    154   
            ser.write_string(&CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_TRANSIT_GATEWAY_ID, val)?;
  155    155   
        }
  156    156   
        if let Some(ref val) = self.peer_transit_gateway_id {
  157    157   
            ser.write_string(&CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_PEER_TRANSIT_GATEWAY_ID, val)?;
  158    158   
        }
  159    159   
        if let Some(ref val) = self.peer_account_id {
  160    160   
            ser.write_string(&CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_PEER_ACCOUNT_ID, val)?;
  161    161   
        }
  162    162   
        if let Some(ref val) = self.peer_region {
  163    163   
            ser.write_string(&CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_PEER_REGION, val)?;
  164    164   
        }
  165    165   
        if let Some(ref val) = self.options {
  166    166   
            ser.write_struct(&CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_OPTIONS, val)?;
  167    167   
        }
  168    168   
        if let Some(ref val) = self.tag_specifications {
  169    169   
            ser.write_list(
  170    170   
                &CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_TAG_SPECIFICATIONS,
  171    171   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  172    172   
                    for item in val {
  173    173   
                        ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
  174    174   
                    }
  175    175   
                    Ok(())
  176    176   
                },
  177    177   
            )?;
  178    178   
        }
  179    179   
        if let Some(ref val) = self.dry_run {
  180    180   
            ser.write_boolean(&CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_MEMBER_DRY_RUN, *val)?;
  181    181   
        }
  182    182   
        Ok(())
  183    183   
    }
  184    184   
}
  185    185   
impl CreateTransitGatewayPeeringAttachmentInput {
  186    186   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  187         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  188         -
        deserializer: &mut D,
         187  +
    pub fn deserialize(
         188  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  189    189   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  190    190   
        #[allow(unused_variables, unused_mut)]
  191    191   
        let mut builder = Self::builder();
  192    192   
        #[allow(
  193    193   
            unused_variables,
  194    194   
            unreachable_code,
  195    195   
            clippy::single_match,
  196    196   
            clippy::match_single_binding,
  197    197   
            clippy::diverging_sub_expression
  198    198   
        )]
  199         -
        deserializer.read_struct(&CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_SCHEMA, (), |_, member, deser| {
         199  +
        deserializer.read_struct(&CREATETRANSITGATEWAYPEERINGATTACHMENTINPUT_SCHEMA, &mut |member, deser| {
  200    200   
            match member.member_index() {
  201    201   
                Some(0) => {
  202    202   
                    builder.transit_gateway_id = Some(deser.read_string(member)?);
  203    203   
                }
  204    204   
                Some(1) => {
  205    205   
                    builder.peer_transit_gateway_id = Some(deser.read_string(member)?);
  206    206   
                }
  207    207   
                Some(2) => {
  208    208   
                    builder.peer_account_id = Some(deser.read_string(member)?);
  209    209   
                }
  210    210   
                Some(3) => {
  211    211   
                    builder.peer_region = Some(deser.read_string(member)?);
  212    212   
                }
  213    213   
                Some(4) => {
  214    214   
                    builder.options = Some(crate::types::CreateTransitGatewayPeeringAttachmentRequestOptions::deserialize(deser)?);
  215    215   
                }
  216    216   
                Some(5) => {
  217    217   
                    builder.tag_specifications = Some({
  218         -
                        let container = if let Some(cap) = deser.container_size() {
  219         -
                            Vec::with_capacity(cap)
  220         -
                        } else {
  221         -
                            Vec::new()
  222         -
                        };
  223         -
                        deser.read_list(member, container, |mut list, deser| {
  224         -
                            list.push(crate::types::TagSpecification::deserialize(deser)?);
  225         -
                            Ok(list)
  226         -
                        })?
         218  +
                        let mut container = Vec::new();
         219  +
                        deser.read_list(member, &mut |deser| {
         220  +
                            container.push(crate::types::TagSpecification::deserialize(deser)?);
         221  +
                            Ok(())
         222  +
                        })?;
         223  +
                        container
  227    224   
                    });
  228    225   
                }
  229    226   
                Some(6) => {
  230    227   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  231    228   
                }
  232    229   
                _ => {}
  233    230   
            }
  234    231   
            Ok(())
  235    232   
        })?;
         233  +
        builder.transit_gateway_id = builder.transit_gateway_id.or(Some(String::new()));
         234  +
        builder.peer_transit_gateway_id = builder.peer_transit_gateway_id.or(Some(String::new()));
         235  +
        builder.peer_account_id = builder.peer_account_id.or(Some(String::new()));
         236  +
        builder.peer_region = builder.peer_region.or(Some(String::new()));
  236    237   
        builder
  237    238   
            .build()
  238    239   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  239    240   
    }
  240    241   
}
         242  +
impl CreateTransitGatewayPeeringAttachmentInput {
         243  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         244  +
    pub fn deserialize_with_response(
         245  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         246  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         247  +
        _status: u16,
         248  +
        _body: &[u8],
         249  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         250  +
        Self::deserialize(deserializer)
         251  +
    }
         252  +
}
  241    253   
impl CreateTransitGatewayPeeringAttachmentInput {
  242    254   
    /// Creates a new builder-style object to manufacture [`CreateTransitGatewayPeeringAttachmentInput`](crate::operation::create_transit_gateway_peering_attachment::CreateTransitGatewayPeeringAttachmentInput).
  243    255   
    pub fn builder() -> crate::operation::create_transit_gateway_peering_attachment::builders::CreateTransitGatewayPeeringAttachmentInputBuilder {
  244    256   
        crate::operation::create_transit_gateway_peering_attachment::builders::CreateTransitGatewayPeeringAttachmentInputBuilder::default()
  245    257   
    }
  246    258   
}
  247    259   
  248    260   
/// A builder for [`CreateTransitGatewayPeeringAttachmentInput`](crate::operation::create_transit_gateway_peering_attachment::CreateTransitGatewayPeeringAttachmentInput).
  249    261   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  250    262   
#[non_exhaustive]