AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_vpc_endpoint_service_permissions/_modify_vpc_endpoint_service_permissions_output.rs

@@ -6,6 +142,194 @@
   26     26   
    "com.amazonaws.ec2.synthetic",
   27     27   
    "ModifyVpcEndpointServicePermissionsOutput",
   28     28   
);
   29     29   
static MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_MEMBER_ADDED_PRINCIPALS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static(
   31     31   
        "com.amazonaws.ec2.synthetic#ModifyVpcEndpointServicePermissionsOutput$AddedPrincipals",
   32     32   
        "com.amazonaws.ec2.synthetic",
   33     33   
        "ModifyVpcEndpointServicePermissionsOutput",
   34     34   
    ),
   35     35   
    ::aws_smithy_schema::ShapeType::List,
   36         -
    "added_principals",
          36  +
    "AddedPrincipals",
   37     37   
    0,
   38     38   
)
   39     39   
.with_xml_name("addedPrincipalSet");
   40     40   
static MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_MEMBER_RETURN_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.ec2.synthetic#ModifyVpcEndpointServicePermissionsOutput$ReturnValue",
   43     43   
        "com.amazonaws.ec2.synthetic",
   44     44   
        "ModifyVpcEndpointServicePermissionsOutput",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::Boolean,
   47         -
    "return_value",
          47  +
    "ReturnValue",
   48     48   
    1,
   49     49   
)
   50     50   
.with_xml_name("return");
          51  +
static MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          52  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          53  +
    ::aws_smithy_schema::ShapeType::String,
          54  +
    "request_id",
          55  +
    2,
          56  +
)
          57  +
.with_http_header("x-amzn-requestid");
   51     58   
static MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   52     59   
    MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_SCHEMA_ID,
   53     60   
    ::aws_smithy_schema::ShapeType::Structure,
   54     61   
    &[
   55     62   
        &MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_MEMBER_ADDED_PRINCIPALS,
   56     63   
        &MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_MEMBER_RETURN_VALUE,
          64  +
        &MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_MEMBER__REQUEST_ID,
   57     65   
    ],
   58     66   
);
   59     67   
impl ModifyVpcEndpointServicePermissionsOutput {
   60     68   
    /// The schema for this shape.
   61     69   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_SCHEMA;
   62     70   
}
   63     71   
impl ::aws_smithy_schema::serde::SerializableStruct for ModifyVpcEndpointServicePermissionsOutput {
   64     72   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   65     73   
    fn serialize_members(
   66     74   
        &self,
   67     75   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   68     76   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   69     77   
        if let Some(ref val) = self.added_principals {
   70     78   
            ser.write_list(
   71     79   
                &MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_MEMBER_ADDED_PRINCIPALS,
   72     80   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   73     81   
                    for item in val {
   74     82   
                        ser.write_struct(crate::types::AddedPrincipal::SCHEMA, item)?;
   75     83   
                    }
   76     84   
                    Ok(())
   77     85   
                },
   78     86   
            )?;
   79     87   
        }
   80     88   
        if let Some(ref val) = self.return_value {
   81     89   
            ser.write_boolean(&MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_MEMBER_RETURN_VALUE, *val)?;
   82     90   
        }
   83     91   
        Ok(())
   84     92   
    }
   85     93   
}
   86     94   
impl ModifyVpcEndpointServicePermissionsOutput {
   87     95   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   88         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   89         -
        deserializer: &mut D,
          96  +
    pub fn deserialize(
          97  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   90     98   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   91     99   
        #[allow(unused_variables, unused_mut)]
   92    100   
        let mut builder = Self::builder();
   93    101   
        #[allow(
   94    102   
            unused_variables,
   95    103   
            unreachable_code,
   96    104   
            clippy::single_match,
   97    105   
            clippy::match_single_binding,
   98    106   
            clippy::diverging_sub_expression
   99    107   
        )]
  100         -
        deserializer.read_struct(&MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_SCHEMA, &mut |member, deser| {
  101    109   
            match member.member_index() {
  102    110   
                Some(0) => {
  103    111   
                    builder.added_principals = Some({
  104         -
                        let container = if let Some(cap) = deser.container_size() {
  105         -
                            Vec::with_capacity(cap)
  106         -
                        } else {
  107         -
                            Vec::new()
  108         -
                        };
  109         -
                        deser.read_list(member, container, |mut list, deser| {
  110         -
                            list.push(crate::types::AddedPrincipal::deserialize(deser)?);
  111         -
                            Ok(list)
  112         -
                        })?
         112  +
                        let mut container = Vec::new();
         113  +
                        deser.read_list(member, &mut |deser| {
         114  +
                            container.push(crate::types::AddedPrincipal::deserialize(deser)?);
         115  +
                            Ok(())
         116  +
                        })?;
         117  +
                        container
         118  +
                    });
         119  +
                }
         120  +
                Some(1) => {
         121  +
                    builder.return_value = Some(deser.read_boolean(member)?);
         122  +
                }
         123  +
                Some(2) => {
         124  +
                    builder._request_id = Some(deser.read_string(member)?);
         125  +
                }
         126  +
                _ => {}
         127  +
            }
         128  +
            Ok(())
         129  +
        })?;
         130  +
        Ok(builder.build())
         131  +
    }
         132  +
}
         133  +
impl ModifyVpcEndpointServicePermissionsOutput {
         134  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         135  +
    /// Header-bound members are read directly from headers, avoiding runtime
         136  +
    /// member iteration overhead. Body members are read via the deserializer.
         137  +
    pub fn deserialize_with_response(
         138  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         139  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         140  +
        _status: u16,
         141  +
        _body: &[u8],
         142  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         143  +
        #[allow(unused_variables, unused_mut)]
         144  +
        let mut builder = Self::builder();
         145  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         146  +
            builder._request_id = Some(val.to_string());
         147  +
        }
         148  +
        #[allow(
         149  +
            unused_variables,
         150  +
            unreachable_code,
         151  +
            clippy::single_match,
         152  +
            clippy::match_single_binding,
         153  +
            clippy::diverging_sub_expression
         154  +
        )]
         155  +
        deserializer.read_struct(&MODIFYVPCENDPOINTSERVICEPERMISSIONSOUTPUT_SCHEMA, &mut |member, deser| {
         156  +
            match member.member_index() {
         157  +
                Some(0) => {
         158  +
                    builder.added_principals = Some({
         159  +
                        let mut container = Vec::new();
         160  +
                        deser.read_list(member, &mut |deser| {
         161  +
                            container.push(crate::types::AddedPrincipal::deserialize(deser)?);
         162  +
                            Ok(())
         163  +
                        })?;
         164  +
                        container
  113    165   
                    });
  114    166   
                }
  115    167   
                Some(1) => {
  116    168   
                    builder.return_value = Some(deser.read_boolean(member)?);
  117    169   
                }
  118    170   
                _ => {}
  119    171   
            }
  120    172   
            Ok(())
  121    173   
        })?;
  122    174   
        Ok(builder.build())

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_vpc_peering_connection_options/_modify_vpc_peering_connection_options_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_vpc_peering_connection_options/_modify_vpc_peering_connection_options_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_vpc_tenancy/_modify_vpc_tenancy_input.rs

@@ -9,9 +156,168 @@
   29     29   
    "com.amazonaws.ec2.synthetic",
   30     30   
    "ModifyVpcTenancyInput",
   31     31   
);
   32     32   
static MODIFYVPCTENANCYINPUT_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static(
   34     34   
        "com.amazonaws.ec2.synthetic#ModifyVpcTenancyInput$VpcId",
   35     35   
        "com.amazonaws.ec2.synthetic",
   36     36   
        "ModifyVpcTenancyInput",
   37     37   
    ),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "vpc_id",
          39  +
    "VpcId",
   40     40   
    0,
   41     41   
);
   42     42   
static MODIFYVPCTENANCYINPUT_MEMBER_INSTANCE_TENANCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.ec2.synthetic#ModifyVpcTenancyInput$InstanceTenancy",
   45     45   
        "com.amazonaws.ec2.synthetic",
   46     46   
        "ModifyVpcTenancyInput",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "instance_tenancy",
          49  +
    "InstanceTenancy",
   50     50   
    1,
   51     51   
);
   52     52   
static MODIFYVPCTENANCYINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.ec2.synthetic#ModifyVpcTenancyInput$DryRun",
   55     55   
        "com.amazonaws.ec2.synthetic",
   56     56   
        "ModifyVpcTenancyInput",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::Boolean,
   59         -
    "dry_run",
          59  +
    "DryRun",
   60     60   
    2,
   61     61   
);
   62     62   
static MODIFYVPCTENANCYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   63     63   
    MODIFYVPCTENANCYINPUT_SCHEMA_ID,
   64     64   
    ::aws_smithy_schema::ShapeType::Structure,
   65     65   
    &[
   66     66   
        &MODIFYVPCTENANCYINPUT_MEMBER_VPC_ID,
   67     67   
        &MODIFYVPCTENANCYINPUT_MEMBER_INSTANCE_TENANCY,
   68     68   
        &MODIFYVPCTENANCYINPUT_MEMBER_DRY_RUN,
   69     69   
    ],
   70     70   
);
   71     71   
impl ModifyVpcTenancyInput {
   72     72   
    /// The schema for this shape.
   73     73   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MODIFYVPCTENANCYINPUT_SCHEMA;
   74     74   
}
   75     75   
impl ::aws_smithy_schema::serde::SerializableStruct for ModifyVpcTenancyInput {
   76     76   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   77     77   
    fn serialize_members(
   78     78   
        &self,
   79     79   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   80     80   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   81     81   
        if let Some(ref val) = self.vpc_id {
   82     82   
            ser.write_string(&MODIFYVPCTENANCYINPUT_MEMBER_VPC_ID, val)?;
   83     83   
        }
   84     84   
        if let Some(ref val) = self.instance_tenancy {
   85     85   
            ser.write_string(&MODIFYVPCTENANCYINPUT_MEMBER_INSTANCE_TENANCY, val.as_str())?;
   86     86   
        }
   87     87   
        if let Some(ref val) = self.dry_run {
   88     88   
            ser.write_boolean(&MODIFYVPCTENANCYINPUT_MEMBER_DRY_RUN, *val)?;
   89     89   
        }
   90     90   
        Ok(())
   91     91   
    }
   92     92   
}
   93     93   
impl ModifyVpcTenancyInput {
   94     94   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   95         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   96         -
        deserializer: &mut D,
          95  +
    pub fn deserialize(
          96  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   97     97   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   98     98   
        #[allow(unused_variables, unused_mut)]
   99     99   
        let mut builder = Self::builder();
  100    100   
        #[allow(
  101    101   
            unused_variables,
  102    102   
            unreachable_code,
  103    103   
            clippy::single_match,
  104    104   
            clippy::match_single_binding,
  105    105   
            clippy::diverging_sub_expression
  106    106   
        )]
  107         -
        deserializer.read_struct(&MODIFYVPCTENANCYINPUT_SCHEMA, (), |_, member, deser| {
         107  +
        deserializer.read_struct(&MODIFYVPCTENANCYINPUT_SCHEMA, &mut |member, deser| {
  108    108   
            match member.member_index() {
  109    109   
                Some(0) => {
  110    110   
                    builder.vpc_id = Some(deser.read_string(member)?);
  111    111   
                }
  112    112   
                Some(1) => {
  113    113   
                    builder.instance_tenancy = Some(crate::types::VpcTenancy::from(deser.read_string(member)?.as_str()));
  114    114   
                }
  115    115   
                Some(2) => {
  116    116   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  117    117   
                }
  118    118   
                _ => {}
  119    119   
            }
  120    120   
            Ok(())
  121    121   
        })?;
         122  +
        builder.vpc_id = builder.vpc_id.or(Some(String::new()));
  122    123   
        builder
  123    124   
            .build()
  124    125   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  125    126   
    }
  126    127   
}
         128  +
impl ModifyVpcTenancyInput {
         129  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         130  +
    pub fn deserialize_with_response(
         131  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         132  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         133  +
        _status: u16,
         134  +
        _body: &[u8],
         135  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         136  +
        Self::deserialize(deserializer)
         137  +
    }
         138  +
}
  127    139   
impl ModifyVpcTenancyInput {
  128    140   
    /// Creates a new builder-style object to manufacture [`ModifyVpcTenancyInput`](crate::operation::modify_vpc_tenancy::ModifyVpcTenancyInput).
  129    141   
    pub fn builder() -> crate::operation::modify_vpc_tenancy::builders::ModifyVpcTenancyInputBuilder {
  130    142   
        crate::operation::modify_vpc_tenancy::builders::ModifyVpcTenancyInputBuilder::default()
  131    143   
    }
  132    144   
}
  133    145   
  134    146   
/// A builder for [`ModifyVpcTenancyInput`](crate::operation::modify_vpc_tenancy::ModifyVpcTenancyInput).
  135    147   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  136    148   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_vpc_tenancy/_modify_vpc_tenancy_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_vpn_connection/_modify_vpn_connection_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_vpn_connection/_modify_vpn_connection_output.rs

@@ -1,1 +97,144 @@
   18     18   
    "com.amazonaws.ec2.synthetic",
   19     19   
    "ModifyVpnConnectionOutput",
   20     20   
);
   21     21   
static MODIFYVPNCONNECTIONOUTPUT_MEMBER_VPN_CONNECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.ec2.synthetic#ModifyVpnConnectionOutput$VpnConnection",
   24     24   
        "com.amazonaws.ec2.synthetic",
   25     25   
        "ModifyVpnConnectionOutput",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28         -
    "vpn_connection",
          28  +
    "VpnConnection",
   29     29   
    0,
   30     30   
)
   31     31   
.with_xml_name("vpnConnection");
          32  +
static MODIFYVPNCONNECTIONOUTPUT_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 MODIFYVPNCONNECTIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     40   
    MODIFYVPNCONNECTIONOUTPUT_SCHEMA_ID,
   34     41   
    ::aws_smithy_schema::ShapeType::Structure,
   35         -
    &[&MODIFYVPNCONNECTIONOUTPUT_MEMBER_VPN_CONNECTION],
          42  +
    &[
          43  +
        &MODIFYVPNCONNECTIONOUTPUT_MEMBER_VPN_CONNECTION,
          44  +
        &MODIFYVPNCONNECTIONOUTPUT_MEMBER__REQUEST_ID,
          45  +
    ],
   36     46   
);
   37     47   
impl ModifyVpnConnectionOutput {
   38     48   
    /// The schema for this shape.
   39     49   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MODIFYVPNCONNECTIONOUTPUT_SCHEMA;
   40     50   
}
   41     51   
impl ::aws_smithy_schema::serde::SerializableStruct for ModifyVpnConnectionOutput {
   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.vpn_connection {
   48     58   
            ser.write_struct(&MODIFYVPNCONNECTIONOUTPUT_MEMBER_VPN_CONNECTION, val)?;
   49     59   
        }
   50     60   
        Ok(())
   51     61   
    }
   52     62   
}
   53     63   
impl ModifyVpnConnectionOutput {
   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(&MODIFYVPNCONNECTIONOUTPUT_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&MODIFYVPNCONNECTIONOUTPUT_SCHEMA, &mut |member, deser| {
          78  +
            match member.member_index() {
          79  +
                Some(0) => {
          80  +
                    builder.vpn_connection = Some(crate::types::VpnConnection::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 ModifyVpnConnectionOutput {
          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(&MODIFYVPNCONNECTIONOUTPUT_SCHEMA, &mut |member, deser| {
   68    115   
            match member.member_index() {
   69    116   
                Some(0) => {
   70    117   
                    builder.vpn_connection = Some(crate::types::VpnConnection::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/modify_vpn_connection_options.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 `ModifyVpnConnectionOptions`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ModifyVpnConnectionOptions;
    6      6   
impl ModifyVpnConnectionOptions {
    7      7   
    /// Creates a new `ModifyVpnConnectionOptions`
    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::modify_vpn_connection_options::ModifyVpnConnectionOptionsInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::modify_vpn_connection_options::ModifyVpnConnectionOptionsOutput::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::modify_vpn_connection_options::ModifyVpnConnectionOptionsInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::modify_vpn_connection_options::ModifyVpnConnectionOptionsOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::modify_vpn_connection_options::ModifyVpnConnectionOptionsError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -119,125 +181,188 @@
  139    145   
                crate::operation::modify_vpn_connection_options::ModifyVpnConnectionOptionsError,
  140    146   
            >::new());
  141    147   
  142    148   
        ::std::borrow::Cow::Owned(rcb)
  143    149   
    }
  144    150   
}
  145    151   
  146    152   
#[derive(Debug)]
  147    153   
struct ModifyVpnConnectionOptionsResponseDeserializer;
  148    154   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ModifyVpnConnectionOptionsResponseDeserializer {
  149         -
    fn deserialize_nonstreaming(
         155  +
    fn deserialize_nonstreaming_with_config(
  150    156   
        &self,
  151    157   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         158  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  152    159   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  153    160   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  154    161   
        let headers = response.headers();
  155    162   
        let body = response.body().bytes().expect("body loaded");
  156    163   
        #[allow(unused_mut)]
  157    164   
        let mut force_error = false;
  158    165   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  159    166   
        let parse_result = if !success && status != 200 || force_error {
  160    167   
            crate::protocol_serde::shape_modify_vpn_connection_options::de_modify_vpn_connection_options_http_error(status, headers, body)
  161    168   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_vpn_connection_options/_modify_vpn_connection_options_input.rs

@@ -35,35 +233,245 @@
   55     55   
    "com.amazonaws.ec2.synthetic",
   56     56   
    "ModifyVpnConnectionOptionsInput",
   57     57   
);
   58     58   
static MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_VPN_CONNECTION_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#ModifyVpnConnectionOptionsInput$VpnConnectionId",
   61     61   
        "com.amazonaws.ec2.synthetic",
   62     62   
        "ModifyVpnConnectionOptionsInput",
   63     63   
    ),
   64     64   
    ::aws_smithy_schema::ShapeType::String,
   65         -
    "vpn_connection_id",
          65  +
    "VpnConnectionId",
   66     66   
    0,
   67     67   
);
   68     68   
static MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_LOCAL_IPV4_NETWORK_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.ec2.synthetic#ModifyVpnConnectionOptionsInput$LocalIpv4NetworkCidr",
   71     71   
        "com.amazonaws.ec2.synthetic",
   72     72   
        "ModifyVpnConnectionOptionsInput",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "local_ipv4_network_cidr",
          75  +
    "LocalIpv4NetworkCidr",
   76     76   
    1,
   77     77   
);
   78     78   
static MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_REMOTE_IPV4_NETWORK_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.ec2.synthetic#ModifyVpnConnectionOptionsInput$RemoteIpv4NetworkCidr",
   81     81   
        "com.amazonaws.ec2.synthetic",
   82     82   
        "ModifyVpnConnectionOptionsInput",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::String,
   85         -
    "remote_ipv4_network_cidr",
          85  +
    "RemoteIpv4NetworkCidr",
   86     86   
    2,
   87     87   
);
   88     88   
static MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_LOCAL_IPV6_NETWORK_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.ec2.synthetic#ModifyVpnConnectionOptionsInput$LocalIpv6NetworkCidr",
   91     91   
        "com.amazonaws.ec2.synthetic",
   92     92   
        "ModifyVpnConnectionOptionsInput",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::String,
   95         -
    "local_ipv6_network_cidr",
          95  +
    "LocalIpv6NetworkCidr",
   96     96   
    3,
   97     97   
);
   98     98   
static MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_REMOTE_IPV6_NETWORK_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static(
  100    100   
        "com.amazonaws.ec2.synthetic#ModifyVpnConnectionOptionsInput$RemoteIpv6NetworkCidr",
  101    101   
        "com.amazonaws.ec2.synthetic",
  102    102   
        "ModifyVpnConnectionOptionsInput",
  103    103   
    ),
  104    104   
    ::aws_smithy_schema::ShapeType::String,
  105         -
    "remote_ipv6_network_cidr",
         105  +
    "RemoteIpv6NetworkCidr",
  106    106   
    4,
  107    107   
);
  108    108   
static MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static(
  110    110   
        "com.amazonaws.ec2.synthetic#ModifyVpnConnectionOptionsInput$DryRun",
  111    111   
        "com.amazonaws.ec2.synthetic",
  112    112   
        "ModifyVpnConnectionOptionsInput",
  113    113   
    ),
  114    114   
    ::aws_smithy_schema::ShapeType::Boolean,
  115         -
    "dry_run",
         115  +
    "DryRun",
  116    116   
    5,
  117    117   
);
  118    118   
static MODIFYVPNCONNECTIONOPTIONSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  119    119   
    MODIFYVPNCONNECTIONOPTIONSINPUT_SCHEMA_ID,
  120    120   
    ::aws_smithy_schema::ShapeType::Structure,
  121    121   
    &[
  122    122   
        &MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_VPN_CONNECTION_ID,
  123    123   
        &MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_LOCAL_IPV4_NETWORK_CIDR,
  124    124   
        &MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_REMOTE_IPV4_NETWORK_CIDR,
  125    125   
        &MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_LOCAL_IPV6_NETWORK_CIDR,
  126    126   
        &MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_REMOTE_IPV6_NETWORK_CIDR,
  127    127   
        &MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_DRY_RUN,
  128    128   
    ],
  129    129   
);
  130    130   
impl ModifyVpnConnectionOptionsInput {
  131    131   
    /// The schema for this shape.
  132    132   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MODIFYVPNCONNECTIONOPTIONSINPUT_SCHEMA;
  133    133   
}
  134    134   
impl ::aws_smithy_schema::serde::SerializableStruct for ModifyVpnConnectionOptionsInput {
  135    135   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  136    136   
    fn serialize_members(
  137    137   
        &self,
  138    138   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  139    139   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  140    140   
        if let Some(ref val) = self.vpn_connection_id {
  141    141   
            ser.write_string(&MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_VPN_CONNECTION_ID, val)?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.local_ipv4_network_cidr {
  144    144   
            ser.write_string(&MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_LOCAL_IPV4_NETWORK_CIDR, val)?;
  145    145   
        }
  146    146   
        if let Some(ref val) = self.remote_ipv4_network_cidr {
  147    147   
            ser.write_string(&MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_REMOTE_IPV4_NETWORK_CIDR, val)?;
  148    148   
        }
  149    149   
        if let Some(ref val) = self.local_ipv6_network_cidr {
  150    150   
            ser.write_string(&MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_LOCAL_IPV6_NETWORK_CIDR, val)?;
  151    151   
        }
  152    152   
        if let Some(ref val) = self.remote_ipv6_network_cidr {
  153    153   
            ser.write_string(&MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_REMOTE_IPV6_NETWORK_CIDR, val)?;
  154    154   
        }
  155    155   
        if let Some(ref val) = self.dry_run {
  156    156   
            ser.write_boolean(&MODIFYVPNCONNECTIONOPTIONSINPUT_MEMBER_DRY_RUN, *val)?;
  157    157   
        }
  158    158   
        Ok(())
  159    159   
    }
  160    160   
}
  161    161   
impl ModifyVpnConnectionOptionsInput {
  162    162   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  163         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  164         -
        deserializer: &mut D,
         163  +
    pub fn deserialize(
         164  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  165    165   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  166    166   
        #[allow(unused_variables, unused_mut)]
  167    167   
        let mut builder = Self::builder();
  168    168   
        #[allow(
  169    169   
            unused_variables,
  170    170   
            unreachable_code,
  171    171   
            clippy::single_match,
  172    172   
            clippy::match_single_binding,
  173    173   
            clippy::diverging_sub_expression
  174    174   
        )]
  175         -
        deserializer.read_struct(&MODIFYVPNCONNECTIONOPTIONSINPUT_SCHEMA, (), |_, member, deser| {
         175  +
        deserializer.read_struct(&MODIFYVPNCONNECTIONOPTIONSINPUT_SCHEMA, &mut |member, deser| {
  176    176   
            match member.member_index() {
  177    177   
                Some(0) => {
  178    178   
                    builder.vpn_connection_id = Some(deser.read_string(member)?);
  179    179   
                }
  180    180   
                Some(1) => {
  181    181   
                    builder.local_ipv4_network_cidr = Some(deser.read_string(member)?);
  182    182   
                }
  183    183   
                Some(2) => {
  184    184   
                    builder.remote_ipv4_network_cidr = Some(deser.read_string(member)?);
  185    185   
                }
  186    186   
                Some(3) => {
  187    187   
                    builder.local_ipv6_network_cidr = Some(deser.read_string(member)?);
  188    188   
                }
  189    189   
                Some(4) => {
  190    190   
                    builder.remote_ipv6_network_cidr = Some(deser.read_string(member)?);
  191    191   
                }
  192    192   
                Some(5) => {
  193    193   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  194    194   
                }
  195    195   
                _ => {}
  196    196   
            }
  197    197   
            Ok(())
  198    198   
        })?;
         199  +
        builder.vpn_connection_id = builder.vpn_connection_id.or(Some(String::new()));
  199    200   
        builder
  200    201   
            .build()
  201    202   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  202    203   
    }
  203    204   
}
         205  +
impl ModifyVpnConnectionOptionsInput {
         206  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         207  +
    pub fn deserialize_with_response(
         208  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         209  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         210  +
        _status: u16,
         211  +
        _body: &[u8],
         212  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         213  +
        Self::deserialize(deserializer)
         214  +
    }
         215  +
}
  204    216   
impl ModifyVpnConnectionOptionsInput {
  205    217   
    /// Creates a new builder-style object to manufacture [`ModifyVpnConnectionOptionsInput`](crate::operation::modify_vpn_connection_options::ModifyVpnConnectionOptionsInput).
  206    218   
    pub fn builder() -> crate::operation::modify_vpn_connection_options::builders::ModifyVpnConnectionOptionsInputBuilder {
  207    219   
        crate::operation::modify_vpn_connection_options::builders::ModifyVpnConnectionOptionsInputBuilder::default()
  208    220   
    }
  209    221   
}
  210    222   
  211    223   
/// A builder for [`ModifyVpnConnectionOptionsInput`](crate::operation::modify_vpn_connection_options::ModifyVpnConnectionOptionsInput).
  212    224   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  213    225   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_vpn_connection_options/_modify_vpn_connection_options_output.rs

@@ -1,1 +97,144 @@
   18     18   
    "com.amazonaws.ec2.synthetic",
   19     19   
    "ModifyVpnConnectionOptionsOutput",
   20     20   
);
   21     21   
static MODIFYVPNCONNECTIONOPTIONSOUTPUT_MEMBER_VPN_CONNECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.ec2.synthetic#ModifyVpnConnectionOptionsOutput$VpnConnection",
   24     24   
        "com.amazonaws.ec2.synthetic",
   25     25   
        "ModifyVpnConnectionOptionsOutput",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28         -
    "vpn_connection",
          28  +
    "VpnConnection",
   29     29   
    0,
   30     30   
)
   31     31   
.with_xml_name("vpnConnection");
          32  +
static MODIFYVPNCONNECTIONOPTIONSOUTPUT_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 MODIFYVPNCONNECTIONOPTIONSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     40   
    MODIFYVPNCONNECTIONOPTIONSOUTPUT_SCHEMA_ID,
   34     41   
    ::aws_smithy_schema::ShapeType::Structure,
   35         -
    &[&MODIFYVPNCONNECTIONOPTIONSOUTPUT_MEMBER_VPN_CONNECTION],
          42  +
    &[
          43  +
        &MODIFYVPNCONNECTIONOPTIONSOUTPUT_MEMBER_VPN_CONNECTION,
          44  +
        &MODIFYVPNCONNECTIONOPTIONSOUTPUT_MEMBER__REQUEST_ID,
          45  +
    ],
   36     46   
);
   37     47   
impl ModifyVpnConnectionOptionsOutput {
   38     48   
    /// The schema for this shape.
   39     49   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MODIFYVPNCONNECTIONOPTIONSOUTPUT_SCHEMA;
   40     50   
}
   41     51   
impl ::aws_smithy_schema::serde::SerializableStruct for ModifyVpnConnectionOptionsOutput {
   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.vpn_connection {
   48     58   
            ser.write_struct(&MODIFYVPNCONNECTIONOPTIONSOUTPUT_MEMBER_VPN_CONNECTION, val)?;
   49     59   
        }
   50     60   
        Ok(())
   51     61   
    }
   52     62   
}
   53     63   
impl ModifyVpnConnectionOptionsOutput {
   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(&MODIFYVPNCONNECTIONOPTIONSOUTPUT_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&MODIFYVPNCONNECTIONOPTIONSOUTPUT_SCHEMA, &mut |member, deser| {
          78  +
            match member.member_index() {
          79  +
                Some(0) => {
          80  +
                    builder.vpn_connection = Some(crate::types::VpnConnection::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 ModifyVpnConnectionOptionsOutput {
          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(&MODIFYVPNCONNECTIONOPTIONSOUTPUT_SCHEMA, &mut |member, deser| {
   68    115   
            match member.member_index() {
   69    116   
                Some(0) => {
   70    117   
                    builder.vpn_connection = Some(crate::types::VpnConnection::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/modify_vpn_tunnel_certificate.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 `ModifyVpnTunnelCertificate`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ModifyVpnTunnelCertificate;
    6      6   
impl ModifyVpnTunnelCertificate {
    7      7   
    /// Creates a new `ModifyVpnTunnelCertificate`
    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::modify_vpn_tunnel_certificate::ModifyVpnTunnelCertificateInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::modify_vpn_tunnel_certificate::ModifyVpnTunnelCertificateOutput::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::modify_vpn_tunnel_certificate::ModifyVpnTunnelCertificateInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::modify_vpn_tunnel_certificate::ModifyVpnTunnelCertificateOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::modify_vpn_tunnel_certificate::ModifyVpnTunnelCertificateError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -119,125 +181,188 @@
  139    145   
                crate::operation::modify_vpn_tunnel_certificate::ModifyVpnTunnelCertificateError,
  140    146   
            >::new());
  141    147   
  142    148   
        ::std::borrow::Cow::Owned(rcb)
  143    149   
    }
  144    150   
}
  145    151   
  146    152   
#[derive(Debug)]
  147    153   
struct ModifyVpnTunnelCertificateResponseDeserializer;
  148    154   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ModifyVpnTunnelCertificateResponseDeserializer {
  149         -
    fn deserialize_nonstreaming(
         155  +
    fn deserialize_nonstreaming_with_config(
  150    156   
        &self,
  151    157   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         158  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  152    159   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  153    160   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  154    161   
        let headers = response.headers();
  155    162   
        let body = response.body().bytes().expect("body loaded");
  156    163   
        #[allow(unused_mut)]
  157    164   
        let mut force_error = false;
  158    165   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  159    166   
        let parse_result = if !success && status != 200 || force_error {
  160    167   
            crate::protocol_serde::shape_modify_vpn_tunnel_certificate::de_modify_vpn_tunnel_certificate_http_error(status, headers, body)
  161    168   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_vpn_tunnel_certificate/_modify_vpn_tunnel_certificate_input.rs

@@ -9,9 +156,169 @@
   29     29   
    "com.amazonaws.ec2.synthetic",
   30     30   
    "ModifyVpnTunnelCertificateInput",
   31     31   
);
   32     32   
static MODIFYVPNTUNNELCERTIFICATEINPUT_MEMBER_VPN_CONNECTION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static(
   34     34   
        "com.amazonaws.ec2.synthetic#ModifyVpnTunnelCertificateInput$VpnConnectionId",
   35     35   
        "com.amazonaws.ec2.synthetic",
   36     36   
        "ModifyVpnTunnelCertificateInput",
   37     37   
    ),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "vpn_connection_id",
          39  +
    "VpnConnectionId",
   40     40   
    0,
   41     41   
);
   42     42   
static MODIFYVPNTUNNELCERTIFICATEINPUT_MEMBER_VPN_TUNNEL_OUTSIDE_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.ec2.synthetic#ModifyVpnTunnelCertificateInput$VpnTunnelOutsideIpAddress",
   45     45   
        "com.amazonaws.ec2.synthetic",
   46     46   
        "ModifyVpnTunnelCertificateInput",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "vpn_tunnel_outside_ip_address",
          49  +
    "VpnTunnelOutsideIpAddress",
   50     50   
    1,
   51     51   
);
   52     52   
static MODIFYVPNTUNNELCERTIFICATEINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.ec2.synthetic#ModifyVpnTunnelCertificateInput$DryRun",
   55     55   
        "com.amazonaws.ec2.synthetic",
   56     56   
        "ModifyVpnTunnelCertificateInput",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::Boolean,
   59         -
    "dry_run",
          59  +
    "DryRun",
   60     60   
    2,
   61     61   
);
   62     62   
static MODIFYVPNTUNNELCERTIFICATEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   63     63   
    MODIFYVPNTUNNELCERTIFICATEINPUT_SCHEMA_ID,
   64     64   
    ::aws_smithy_schema::ShapeType::Structure,
   65     65   
    &[
   66     66   
        &MODIFYVPNTUNNELCERTIFICATEINPUT_MEMBER_VPN_CONNECTION_ID,
   67     67   
        &MODIFYVPNTUNNELCERTIFICATEINPUT_MEMBER_VPN_TUNNEL_OUTSIDE_IP_ADDRESS,
   68     68   
        &MODIFYVPNTUNNELCERTIFICATEINPUT_MEMBER_DRY_RUN,
   69     69   
    ],
   70     70   
);
   71     71   
impl ModifyVpnTunnelCertificateInput {
   72     72   
    /// The schema for this shape.
   73     73   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MODIFYVPNTUNNELCERTIFICATEINPUT_SCHEMA;
   74     74   
}
   75     75   
impl ::aws_smithy_schema::serde::SerializableStruct for ModifyVpnTunnelCertificateInput {
   76     76   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   77     77   
    fn serialize_members(
   78     78   
        &self,
   79     79   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   80     80   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   81     81   
        if let Some(ref val) = self.vpn_connection_id {
   82     82   
            ser.write_string(&MODIFYVPNTUNNELCERTIFICATEINPUT_MEMBER_VPN_CONNECTION_ID, val)?;
   83     83   
        }
   84     84   
        if let Some(ref val) = self.vpn_tunnel_outside_ip_address {
   85     85   
            ser.write_string(&MODIFYVPNTUNNELCERTIFICATEINPUT_MEMBER_VPN_TUNNEL_OUTSIDE_IP_ADDRESS, val)?;
   86     86   
        }
   87     87   
        if let Some(ref val) = self.dry_run {
   88     88   
            ser.write_boolean(&MODIFYVPNTUNNELCERTIFICATEINPUT_MEMBER_DRY_RUN, *val)?;
   89     89   
        }
   90     90   
        Ok(())
   91     91   
    }
   92     92   
}
   93     93   
impl ModifyVpnTunnelCertificateInput {
   94     94   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   95         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   96         -
        deserializer: &mut D,
          95  +
    pub fn deserialize(
          96  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   97     97   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   98     98   
        #[allow(unused_variables, unused_mut)]
   99     99   
        let mut builder = Self::builder();
  100    100   
        #[allow(
  101    101   
            unused_variables,
  102    102   
            unreachable_code,
  103    103   
            clippy::single_match,
  104    104   
            clippy::match_single_binding,
  105    105   
            clippy::diverging_sub_expression
  106    106   
        )]
  107         -
        deserializer.read_struct(&MODIFYVPNTUNNELCERTIFICATEINPUT_SCHEMA, (), |_, member, deser| {
         107  +
        deserializer.read_struct(&MODIFYVPNTUNNELCERTIFICATEINPUT_SCHEMA, &mut |member, deser| {
  108    108   
            match member.member_index() {
  109    109   
                Some(0) => {
  110    110   
                    builder.vpn_connection_id = Some(deser.read_string(member)?);
  111    111   
                }
  112    112   
                Some(1) => {
  113    113   
                    builder.vpn_tunnel_outside_ip_address = Some(deser.read_string(member)?);
  114    114   
                }
  115    115   
                Some(2) => {
  116    116   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  117    117   
                }
  118    118   
                _ => {}
  119    119   
            }
  120    120   
            Ok(())
  121    121   
        })?;
         122  +
        builder.vpn_connection_id = builder.vpn_connection_id.or(Some(String::new()));
         123  +
        builder.vpn_tunnel_outside_ip_address = builder.vpn_tunnel_outside_ip_address.or(Some(String::new()));
  122    124   
        builder
  123    125   
            .build()
  124    126   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  125    127   
    }
  126    128   
}
         129  +
impl ModifyVpnTunnelCertificateInput {
         130  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         131  +
    pub fn deserialize_with_response(
         132  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         133  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         134  +
        _status: u16,
         135  +
        _body: &[u8],
         136  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         137  +
        Self::deserialize(deserializer)
         138  +
    }
         139  +
}
  127    140   
impl ModifyVpnTunnelCertificateInput {
  128    141   
    /// Creates a new builder-style object to manufacture [`ModifyVpnTunnelCertificateInput`](crate::operation::modify_vpn_tunnel_certificate::ModifyVpnTunnelCertificateInput).
  129    142   
    pub fn builder() -> crate::operation::modify_vpn_tunnel_certificate::builders::ModifyVpnTunnelCertificateInputBuilder {
  130    143   
        crate::operation::modify_vpn_tunnel_certificate::builders::ModifyVpnTunnelCertificateInputBuilder::default()
  131    144   
    }
  132    145   
}
  133    146   
  134    147   
/// A builder for [`ModifyVpnTunnelCertificateInput`](crate::operation::modify_vpn_tunnel_certificate::ModifyVpnTunnelCertificateInput).
  135    148   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  136    149   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_vpn_tunnel_certificate/_modify_vpn_tunnel_certificate_output.rs

@@ -1,1 +97,144 @@
   18     18   
    "com.amazonaws.ec2.synthetic",
   19     19   
    "ModifyVpnTunnelCertificateOutput",
   20     20   
);
   21     21   
static MODIFYVPNTUNNELCERTIFICATEOUTPUT_MEMBER_VPN_CONNECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.ec2.synthetic#ModifyVpnTunnelCertificateOutput$VpnConnection",
   24     24   
        "com.amazonaws.ec2.synthetic",
   25     25   
        "ModifyVpnTunnelCertificateOutput",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28         -
    "vpn_connection",
          28  +
    "VpnConnection",
   29     29   
    0,
   30     30   
)
   31     31   
.with_xml_name("vpnConnection");
          32  +
static MODIFYVPNTUNNELCERTIFICATEOUTPUT_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 MODIFYVPNTUNNELCERTIFICATEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     40   
    MODIFYVPNTUNNELCERTIFICATEOUTPUT_SCHEMA_ID,
   34     41   
    ::aws_smithy_schema::ShapeType::Structure,
   35         -
    &[&MODIFYVPNTUNNELCERTIFICATEOUTPUT_MEMBER_VPN_CONNECTION],
          42  +
    &[
          43  +
        &MODIFYVPNTUNNELCERTIFICATEOUTPUT_MEMBER_VPN_CONNECTION,
          44  +
        &MODIFYVPNTUNNELCERTIFICATEOUTPUT_MEMBER__REQUEST_ID,
          45  +
    ],
   36     46   
);
   37     47   
impl ModifyVpnTunnelCertificateOutput {
   38     48   
    /// The schema for this shape.
   39     49   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MODIFYVPNTUNNELCERTIFICATEOUTPUT_SCHEMA;
   40     50   
}
   41     51   
impl ::aws_smithy_schema::serde::SerializableStruct for ModifyVpnTunnelCertificateOutput {
   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.vpn_connection {
   48     58   
            ser.write_struct(&MODIFYVPNTUNNELCERTIFICATEOUTPUT_MEMBER_VPN_CONNECTION, val)?;
   49     59   
        }
   50     60   
        Ok(())
   51     61   
    }
   52     62   
}
   53     63   
impl ModifyVpnTunnelCertificateOutput {
   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(&MODIFYVPNTUNNELCERTIFICATEOUTPUT_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&MODIFYVPNTUNNELCERTIFICATEOUTPUT_SCHEMA, &mut |member, deser| {
          78  +
            match member.member_index() {
          79  +
                Some(0) => {
          80  +
                    builder.vpn_connection = Some(crate::types::VpnConnection::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 ModifyVpnTunnelCertificateOutput {
          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(&MODIFYVPNTUNNELCERTIFICATEOUTPUT_SCHEMA, &mut |member, deser| {
   68    115   
            match member.member_index() {
   69    116   
                Some(0) => {
   70    117   
                    builder.vpn_connection = Some(crate::types::VpnConnection::deserialize(deser)?);
   71    118   
                }
   72    119   
                _ => {}
   73    120   
            }
   74    121   
            Ok(())
   75    122   
        })?;
   76    123   
        Ok(builder.build())
   77    124   
    }