AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_acl/_create_network_acl_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_acl_entry/_create_network_acl_entry_input.rs

@@ -53,53 +212,212 @@
   73     73   
    "com.amazonaws.ec2.synthetic",
   74     74   
    "CreateNetworkAclEntryInput",
   75     75   
);
   76     76   
static CREATENETWORKACLENTRYINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   77     77   
    ::aws_smithy_schema::ShapeId::from_static(
   78     78   
        "com.amazonaws.ec2.synthetic#CreateNetworkAclEntryInput$DryRun",
   79     79   
        "com.amazonaws.ec2.synthetic",
   80     80   
        "CreateNetworkAclEntryInput",
   81     81   
    ),
   82     82   
    ::aws_smithy_schema::ShapeType::Boolean,
   83         -
    "dry_run",
          83  +
    "DryRun",
   84     84   
    0,
   85     85   
)
   86     86   
.with_xml_name("dryRun");
   87     87   
static CREATENETWORKACLENTRYINPUT_MEMBER_NETWORK_ACL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static(
   89     89   
        "com.amazonaws.ec2.synthetic#CreateNetworkAclEntryInput$NetworkAclId",
   90     90   
        "com.amazonaws.ec2.synthetic",
   91     91   
        "CreateNetworkAclEntryInput",
   92     92   
    ),
   93     93   
    ::aws_smithy_schema::ShapeType::String,
   94         -
    "network_acl_id",
          94  +
    "NetworkAclId",
   95     95   
    1,
   96     96   
)
   97     97   
.with_xml_name("networkAclId");
   98     98   
static CREATENETWORKACLENTRYINPUT_MEMBER_RULE_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static(
  100    100   
        "com.amazonaws.ec2.synthetic#CreateNetworkAclEntryInput$RuleNumber",
  101    101   
        "com.amazonaws.ec2.synthetic",
  102    102   
        "CreateNetworkAclEntryInput",
  103    103   
    ),
  104    104   
    ::aws_smithy_schema::ShapeType::Integer,
  105         -
    "rule_number",
         105  +
    "RuleNumber",
  106    106   
    2,
  107    107   
)
  108    108   
.with_xml_name("ruleNumber");
  109    109   
static CREATENETWORKACLENTRYINPUT_MEMBER_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.ec2.synthetic#CreateNetworkAclEntryInput$Protocol",
  112    112   
        "com.amazonaws.ec2.synthetic",
  113    113   
        "CreateNetworkAclEntryInput",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "protocol",
         116  +
    "Protocol",
  117    117   
    3,
  118    118   
)
  119    119   
.with_xml_name("protocol");
  120    120   
static CREATENETWORKACLENTRYINPUT_MEMBER_RULE_ACTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  121    121   
    ::aws_smithy_schema::ShapeId::from_static(
  122    122   
        "com.amazonaws.ec2.synthetic#CreateNetworkAclEntryInput$RuleAction",
  123    123   
        "com.amazonaws.ec2.synthetic",
  124    124   
        "CreateNetworkAclEntryInput",
  125    125   
    ),
  126    126   
    ::aws_smithy_schema::ShapeType::String,
  127         -
    "rule_action",
         127  +
    "RuleAction",
  128    128   
    4,
  129    129   
)
  130    130   
.with_xml_name("ruleAction");
  131    131   
static CREATENETWORKACLENTRYINPUT_MEMBER_EGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  132    132   
    ::aws_smithy_schema::ShapeId::from_static(
  133    133   
        "com.amazonaws.ec2.synthetic#CreateNetworkAclEntryInput$Egress",
  134    134   
        "com.amazonaws.ec2.synthetic",
  135    135   
        "CreateNetworkAclEntryInput",
  136    136   
    ),
  137    137   
    ::aws_smithy_schema::ShapeType::Boolean,
  138         -
    "egress",
         138  +
    "Egress",
  139    139   
    5,
  140    140   
)
  141    141   
.with_xml_name("egress");
  142    142   
static CREATENETWORKACLENTRYINPUT_MEMBER_CIDR_BLOCK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  143    143   
    ::aws_smithy_schema::ShapeId::from_static(
  144    144   
        "com.amazonaws.ec2.synthetic#CreateNetworkAclEntryInput$CidrBlock",
  145    145   
        "com.amazonaws.ec2.synthetic",
  146    146   
        "CreateNetworkAclEntryInput",
  147    147   
    ),
  148    148   
    ::aws_smithy_schema::ShapeType::String,
  149         -
    "cidr_block",
         149  +
    "CidrBlock",
  150    150   
    6,
  151    151   
)
  152    152   
.with_xml_name("cidrBlock");
  153    153   
static CREATENETWORKACLENTRYINPUT_MEMBER_IPV6_CIDR_BLOCK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  154    154   
    ::aws_smithy_schema::ShapeId::from_static(
  155    155   
        "com.amazonaws.ec2.synthetic#CreateNetworkAclEntryInput$Ipv6CidrBlock",
  156    156   
        "com.amazonaws.ec2.synthetic",
  157    157   
        "CreateNetworkAclEntryInput",
  158    158   
    ),
  159    159   
    ::aws_smithy_schema::ShapeType::String,
  160         -
    "ipv6_cidr_block",
         160  +
    "Ipv6CidrBlock",
  161    161   
    7,
  162    162   
)
  163    163   
.with_xml_name("ipv6CidrBlock");
  164    164   
static CREATENETWORKACLENTRYINPUT_MEMBER_ICMP_TYPE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  165    165   
    ::aws_smithy_schema::ShapeId::from_static(
  166    166   
        "com.amazonaws.ec2.synthetic#CreateNetworkAclEntryInput$IcmpTypeCode",
  167    167   
        "com.amazonaws.ec2.synthetic",
  168    168   
        "CreateNetworkAclEntryInput",
  169    169   
    ),
  170    170   
    ::aws_smithy_schema::ShapeType::Structure,
  171         -
    "icmp_type_code",
         171  +
    "IcmpTypeCode",
  172    172   
    8,
  173    173   
)
  174    174   
.with_xml_name("Icmp");
  175    175   
static CREATENETWORKACLENTRYINPUT_MEMBER_PORT_RANGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  176    176   
    ::aws_smithy_schema::ShapeId::from_static(
  177    177   
        "com.amazonaws.ec2.synthetic#CreateNetworkAclEntryInput$PortRange",
  178    178   
        "com.amazonaws.ec2.synthetic",
  179    179   
        "CreateNetworkAclEntryInput",
  180    180   
    ),
  181    181   
    ::aws_smithy_schema::ShapeType::Structure,
  182         -
    "port_range",
         182  +
    "PortRange",
  183    183   
    9,
  184    184   
)
  185    185   
.with_xml_name("portRange");
  186    186   
static CREATENETWORKACLENTRYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  187    187   
    CREATENETWORKACLENTRYINPUT_SCHEMA_ID,
  188    188   
    ::aws_smithy_schema::ShapeType::Structure,
  189    189   
    &[
  190    190   
        &CREATENETWORKACLENTRYINPUT_MEMBER_DRY_RUN,
  191    191   
        &CREATENETWORKACLENTRYINPUT_MEMBER_NETWORK_ACL_ID,
  192    192   
        &CREATENETWORKACLENTRYINPUT_MEMBER_RULE_NUMBER,
@@ -217,217 +329,344 @@
  237    237   
            ser.write_struct(&CREATENETWORKACLENTRYINPUT_MEMBER_ICMP_TYPE_CODE, val)?;
  238    238   
        }
  239    239   
        if let Some(ref val) = self.port_range {
  240    240   
            ser.write_struct(&CREATENETWORKACLENTRYINPUT_MEMBER_PORT_RANGE, val)?;
  241    241   
        }
  242    242   
        Ok(())
  243    243   
    }
  244    244   
}
  245    245   
impl CreateNetworkAclEntryInput {
  246    246   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  247         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  248         -
        deserializer: &mut D,
         247  +
    pub fn deserialize(
         248  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  249    249   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  250    250   
        #[allow(unused_variables, unused_mut)]
  251    251   
        let mut builder = Self::builder();
  252    252   
        #[allow(
  253    253   
            unused_variables,
  254    254   
            unreachable_code,
  255    255   
            clippy::single_match,
  256    256   
            clippy::match_single_binding,
  257    257   
            clippy::diverging_sub_expression
  258    258   
        )]
  259         -
        deserializer.read_struct(&CREATENETWORKACLENTRYINPUT_SCHEMA, (), |_, member, deser| {
         259  +
        deserializer.read_struct(&CREATENETWORKACLENTRYINPUT_SCHEMA, &mut |member, deser| {
  260    260   
            match member.member_index() {
  261    261   
                Some(0) => {
  262    262   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  263    263   
                }
  264    264   
                Some(1) => {
  265    265   
                    builder.network_acl_id = Some(deser.read_string(member)?);
  266    266   
                }
  267    267   
                Some(2) => {
  268    268   
                    builder.rule_number = Some(deser.read_integer(member)?);
  269    269   
                }
  270    270   
                Some(3) => {
  271    271   
                    builder.protocol = Some(deser.read_string(member)?);
  272    272   
                }
  273    273   
                Some(4) => {
  274    274   
                    builder.rule_action = Some(crate::types::RuleAction::from(deser.read_string(member)?.as_str()));
  275    275   
                }
  276    276   
                Some(5) => {
  277    277   
                    builder.egress = Some(deser.read_boolean(member)?);
  278    278   
                }
  279    279   
                Some(6) => {
  280    280   
                    builder.cidr_block = Some(deser.read_string(member)?);
  281    281   
                }
  282    282   
                Some(7) => {
  283    283   
                    builder.ipv6_cidr_block = Some(deser.read_string(member)?);
  284    284   
                }
  285    285   
                Some(8) => {
  286    286   
                    builder.icmp_type_code = Some(crate::types::IcmpTypeCode::deserialize(deser)?);
  287    287   
                }
  288    288   
                Some(9) => {
  289    289   
                    builder.port_range = Some(crate::types::PortRange::deserialize(deser)?);
  290    290   
                }
  291    291   
                _ => {}
  292    292   
            }
  293    293   
            Ok(())
  294    294   
        })?;
         295  +
        builder.network_acl_id = builder.network_acl_id.or(Some(String::new()));
         296  +
        builder.rule_number = builder.rule_number.or(Some(0i32));
         297  +
        builder.protocol = builder.protocol.or(Some(String::new()));
         298  +
        builder.egress = builder.egress.or(Some(false));
  295    299   
        builder
  296    300   
            .build()
  297    301   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  298    302   
    }
  299    303   
}
         304  +
impl CreateNetworkAclEntryInput {
         305  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         306  +
    pub fn deserialize_with_response(
         307  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         308  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         309  +
        _status: u16,
         310  +
        _body: &[u8],
         311  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         312  +
        Self::deserialize(deserializer)
         313  +
    }
         314  +
}
  300    315   
impl CreateNetworkAclEntryInput {
  301    316   
    /// Creates a new builder-style object to manufacture [`CreateNetworkAclEntryInput`](crate::operation::create_network_acl_entry::CreateNetworkAclEntryInput).
  302    317   
    pub fn builder() -> crate::operation::create_network_acl_entry::builders::CreateNetworkAclEntryInputBuilder {
  303    318   
        crate::operation::create_network_acl_entry::builders::CreateNetworkAclEntryInputBuilder::default()
  304    319   
    }
  305    320   
}
  306    321   
  307    322   
/// A builder for [`CreateNetworkAclEntryInput`](crate::operation::create_network_acl_entry::CreateNetworkAclEntryInput).
  308    323   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  309    324   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_acl_entry/_create_network_acl_entry_output.rs

@@ -1,1 +80,111 @@
    3      3   
#[non_exhaustive]
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5      5   
pub struct CreateNetworkAclEntryOutput {
    6      6   
    _request_id: Option<String>,
    7      7   
}
    8      8   
static CREATENETWORKACLENTRYOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
    9      9   
    "com.amazonaws.ec2.synthetic#CreateNetworkAclEntryOutput",
   10     10   
    "com.amazonaws.ec2.synthetic",
   11     11   
    "CreateNetworkAclEntryOutput",
   12     12   
);
   13         -
static CREATENETWORKACLENTRYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
   14         -
    ::aws_smithy_schema::Schema::new_struct(CREATENETWORKACLENTRYOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
          13  +
static CREATENETWORKACLENTRYOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          14  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          15  +
    ::aws_smithy_schema::ShapeType::String,
          16  +
    "request_id",
          17  +
    0,
          18  +
)
          19  +
.with_http_header("x-amzn-requestid");
          20  +
static CREATENETWORKACLENTRYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
          21  +
    CREATENETWORKACLENTRYOUTPUT_SCHEMA_ID,
          22  +
    ::aws_smithy_schema::ShapeType::Structure,
          23  +
    &[&CREATENETWORKACLENTRYOUTPUT_MEMBER__REQUEST_ID],
          24  +
);
   15     25   
impl CreateNetworkAclEntryOutput {
   16     26   
    /// The schema for this shape.
   17     27   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATENETWORKACLENTRYOUTPUT_SCHEMA;
   18     28   
}
   19     29   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateNetworkAclEntryOutput {
   20     30   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   21     31   
    fn serialize_members(
   22     32   
        &self,
   23     33   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   24     34   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   25     35   
        Ok(())
   26     36   
    }
   27     37   
}
   28     38   
impl CreateNetworkAclEntryOutput {
   29     39   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   30         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   31         -
        deserializer: &mut D,
          40  +
    pub fn deserialize(
          41  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   32     42   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   33     43   
        #[allow(unused_variables, unused_mut)]
   34     44   
        let mut builder = Self::builder();
   35     45   
        #[allow(
   36     46   
            unused_variables,
   37     47   
            unreachable_code,
   38     48   
            clippy::single_match,
   39     49   
            clippy::match_single_binding,
   40     50   
            clippy::diverging_sub_expression
   41     51   
        )]
   42         -
        deserializer.read_struct(&CREATENETWORKACLENTRYOUTPUT_SCHEMA, (), |_, member, deser| {
          52  +
        deserializer.read_struct(&CREATENETWORKACLENTRYOUTPUT_SCHEMA, &mut |member, deser| {
   43     53   
            match member.member_index() {
          54  +
                Some(0) => {
          55  +
                    builder._request_id = Some(deser.read_string(member)?);
          56  +
                }
   44     57   
                _ => {}
   45     58   
            }
   46     59   
            Ok(())
   47     60   
        })?;
   48     61   
        Ok(builder.build())
   49     62   
    }
   50     63   
}
          64  +
impl CreateNetworkAclEntryOutput {
          65  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          66  +
    /// Header-bound members are read directly from headers, avoiding runtime
          67  +
    /// member iteration overhead. Body members are read via the deserializer.
          68  +
    pub fn deserialize_with_response(
          69  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          70  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          71  +
        _status: u16,
          72  +
        _body: &[u8],
          73  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          74  +
        #[allow(unused_variables, unused_mut)]
          75  +
        let mut builder = Self::builder();
          76  +
        if let Some(val) = headers.get("x-amzn-requestid") {
          77  +
            builder._request_id = Some(val.to_string());
          78  +
        }
          79  +
        Ok(builder.build())
          80  +
    }
          81  +
}
   51     82   
impl ::aws_types::request_id::RequestId for CreateNetworkAclEntryOutput {
   52     83   
    fn request_id(&self) -> Option<&str> {
   53     84   
        self._request_id.as_deref()
   54     85   
    }
   55     86   
}
   56     87   
impl CreateNetworkAclEntryOutput {
   57     88   
    /// Creates a new builder-style object to manufacture [`CreateNetworkAclEntryOutput`](crate::operation::create_network_acl_entry::CreateNetworkAclEntryOutput).
   58     89   
    pub fn builder() -> crate::operation::create_network_acl_entry::builders::CreateNetworkAclEntryOutputBuilder {
   59     90   
        crate::operation::create_network_acl_entry::builders::CreateNetworkAclEntryOutputBuilder::default()
   60     91   
    }

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_insights_access_scope/_create_network_insights_access_scope_input.rs

@@ -27,27 +130,130 @@
   47     47   
    "com.amazonaws.ec2.synthetic",
   48     48   
    "CreateNetworkInsightsAccessScopeInput",
   49     49   
);
   50     50   
static CREATENETWORKINSIGHTSACCESSSCOPEINPUT_MEMBER_MATCH_PATHS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsAccessScopeInput$MatchPaths",
   53     53   
        "com.amazonaws.ec2.synthetic",
   54     54   
        "CreateNetworkInsightsAccessScopeInput",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::List,
   57         -
    "match_paths",
          57  +
    "MatchPaths",
   58     58   
    0,
   59     59   
)
   60     60   
.with_xml_name("MatchPath");
   61     61   
static CREATENETWORKINSIGHTSACCESSSCOPEINPUT_MEMBER_EXCLUDE_PATHS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsAccessScopeInput$ExcludePaths",
   64     64   
        "com.amazonaws.ec2.synthetic",
   65     65   
        "CreateNetworkInsightsAccessScopeInput",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::List,
   68         -
    "exclude_paths",
          68  +
    "ExcludePaths",
   69     69   
    1,
   70     70   
)
   71     71   
.with_xml_name("ExcludePath");
   72     72   
static CREATENETWORKINSIGHTSACCESSSCOPEINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsAccessScopeInput$ClientToken",
   75     75   
        "com.amazonaws.ec2.synthetic",
   76     76   
        "CreateNetworkInsightsAccessScopeInput",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "client_token",
          79  +
    "ClientToken",
   80     80   
    2,
   81     81   
);
   82     82   
static CREATENETWORKINSIGHTSACCESSSCOPEINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsAccessScopeInput$TagSpecifications",
   85     85   
        "com.amazonaws.ec2.synthetic",
   86     86   
        "CreateNetworkInsightsAccessScopeInput",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::List,
   89         -
    "tag_specifications",
          89  +
    "TagSpecifications",
   90     90   
    3,
   91     91   
)
   92     92   
.with_xml_name("TagSpecification");
   93     93   
static CREATENETWORKINSIGHTSACCESSSCOPEINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsAccessScopeInput$DryRun",
   96     96   
        "com.amazonaws.ec2.synthetic",
   97     97   
        "CreateNetworkInsightsAccessScopeInput",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::Boolean,
  100         -
    "dry_run",
         100  +
    "DryRun",
  101    101   
    4,
  102    102   
);
  103    103   
static CREATENETWORKINSIGHTSACCESSSCOPEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  104    104   
    CREATENETWORKINSIGHTSACCESSSCOPEINPUT_SCHEMA_ID,
  105    105   
    ::aws_smithy_schema::ShapeType::Structure,
  106    106   
    &[
  107    107   
        &CREATENETWORKINSIGHTSACCESSSCOPEINPUT_MEMBER_MATCH_PATHS,
  108    108   
        &CREATENETWORKINSIGHTSACCESSSCOPEINPUT_MEMBER_EXCLUDE_PATHS,
  109    109   
        &CREATENETWORKINSIGHTSACCESSSCOPEINPUT_MEMBER_CLIENT_TOKEN,
  110    110   
        &CREATENETWORKINSIGHTSACCESSSCOPEINPUT_MEMBER_TAG_SPECIFICATIONS,
@@ -138,138 +265,268 @@
  158    158   
            )?;
  159    159   
        }
  160    160   
        if let Some(ref val) = self.dry_run {
  161    161   
            ser.write_boolean(&CREATENETWORKINSIGHTSACCESSSCOPEINPUT_MEMBER_DRY_RUN, *val)?;
  162    162   
        }
  163    163   
        Ok(())
  164    164   
    }
  165    165   
}
  166    166   
impl CreateNetworkInsightsAccessScopeInput {
  167    167   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  168         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  169         -
        deserializer: &mut D,
         168  +
    pub fn deserialize(
         169  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  170    170   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  171    171   
        #[allow(unused_variables, unused_mut)]
  172    172   
        let mut builder = Self::builder();
  173    173   
        #[allow(
  174    174   
            unused_variables,
  175    175   
            unreachable_code,
  176    176   
            clippy::single_match,
  177    177   
            clippy::match_single_binding,
  178    178   
            clippy::diverging_sub_expression
  179    179   
        )]
  180         -
        deserializer.read_struct(&CREATENETWORKINSIGHTSACCESSSCOPEINPUT_SCHEMA, (), |_, member, deser| {
         180  +
        deserializer.read_struct(&CREATENETWORKINSIGHTSACCESSSCOPEINPUT_SCHEMA, &mut |member, deser| {
  181    181   
            match member.member_index() {
  182    182   
                Some(0) => {
  183    183   
                    builder.match_paths = Some({
  184         -
                        let container = if let Some(cap) = deser.container_size() {
  185         -
                            Vec::with_capacity(cap)
  186         -
                        } else {
  187         -
                            Vec::new()
  188         -
                        };
  189         -
                        deser.read_list(member, container, |mut list, deser| {
  190         -
                            list.push(crate::types::AccessScopePathRequest::deserialize(deser)?);
  191         -
                            Ok(list)
  192         -
                        })?
         184  +
                        let mut container = Vec::new();
         185  +
                        deser.read_list(member, &mut |deser| {
         186  +
                            container.push(crate::types::AccessScopePathRequest::deserialize(deser)?);
         187  +
                            Ok(())
         188  +
                        })?;
         189  +
                        container
  193    190   
                    });
  194    191   
                }
  195    192   
                Some(1) => {
  196    193   
                    builder.exclude_paths = Some({
  197         -
                        let container = if let Some(cap) = deser.container_size() {
  198         -
                            Vec::with_capacity(cap)
  199         -
                        } else {
  200         -
                            Vec::new()
  201         -
                        };
  202         -
                        deser.read_list(member, container, |mut list, deser| {
  203         -
                            list.push(crate::types::AccessScopePathRequest::deserialize(deser)?);
  204         -
                            Ok(list)
  205         -
                        })?
         194  +
                        let mut container = Vec::new();
         195  +
                        deser.read_list(member, &mut |deser| {
         196  +
                            container.push(crate::types::AccessScopePathRequest::deserialize(deser)?);
         197  +
                            Ok(())
         198  +
                        })?;
         199  +
                        container
  206    200   
                    });
  207    201   
                }
  208    202   
                Some(2) => {
  209    203   
                    builder.client_token = Some(deser.read_string(member)?);
  210    204   
                }
  211    205   
                Some(3) => {
  212    206   
                    builder.tag_specifications = Some({
  213         -
                        let container = if let Some(cap) = deser.container_size() {
  214         -
                            Vec::with_capacity(cap)
  215         -
                        } else {
  216         -
                            Vec::new()
  217         -
                        };
  218         -
                        deser.read_list(member, container, |mut list, deser| {
  219         -
                            list.push(crate::types::TagSpecification::deserialize(deser)?);
  220         -
                            Ok(list)
  221         -
                        })?
         207  +
                        let mut container = Vec::new();
         208  +
                        deser.read_list(member, &mut |deser| {
         209  +
                            container.push(crate::types::TagSpecification::deserialize(deser)?);
         210  +
                            Ok(())
         211  +
                        })?;
         212  +
                        container
  222    213   
                    });
  223    214   
                }
  224    215   
                Some(4) => {
  225    216   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  226    217   
                }
  227    218   
                _ => {}
  228    219   
            }
  229    220   
            Ok(())
  230    221   
        })?;
         222  +
        builder.client_token = builder.client_token.or(Some(String::new()));
  231    223   
        builder
  232    224   
            .build()
  233    225   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  234    226   
    }
  235    227   
}
         228  +
impl CreateNetworkInsightsAccessScopeInput {
         229  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         230  +
    pub fn deserialize_with_response(
         231  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         232  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         233  +
        _status: u16,
         234  +
        _body: &[u8],
         235  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         236  +
        Self::deserialize(deserializer)
         237  +
    }
         238  +
}
  236    239   
impl CreateNetworkInsightsAccessScopeInput {
  237    240   
    /// Creates a new builder-style object to manufacture [`CreateNetworkInsightsAccessScopeInput`](crate::operation::create_network_insights_access_scope::CreateNetworkInsightsAccessScopeInput).
  238    241   
    pub fn builder() -> crate::operation::create_network_insights_access_scope::builders::CreateNetworkInsightsAccessScopeInputBuilder {
  239    242   
        crate::operation::create_network_insights_access_scope::builders::CreateNetworkInsightsAccessScopeInputBuilder::default()
  240    243   
    }
  241    244   
}
  242    245   
  243    246   
/// A builder for [`CreateNetworkInsightsAccessScopeInput`](crate::operation::create_network_insights_access_scope::CreateNetworkInsightsAccessScopeInput).
  244    247   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  245    248   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_insights_access_scope/_create_network_insights_access_scope_output.rs

@@ -5,5 +122,170 @@
   25     25   
    "CreateNetworkInsightsAccessScopeOutput",
   26     26   
);
   27     27   
static CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE: ::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#CreateNetworkInsightsAccessScopeOutput$NetworkInsightsAccessScope",
   31     31   
            "com.amazonaws.ec2.synthetic",
   32     32   
            "CreateNetworkInsightsAccessScopeOutput",
   33     33   
        ),
   34     34   
        ::aws_smithy_schema::ShapeType::Structure,
   35         -
        "network_insights_access_scope",
          35  +
        "NetworkInsightsAccessScope",
   36     36   
        0,
   37     37   
    )
   38     38   
    .with_xml_name("networkInsightsAccessScope");
   39     39   
static CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_CONTENT: ::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#CreateNetworkInsightsAccessScopeOutput$NetworkInsightsAccessScopeContent",
   43     43   
            "com.amazonaws.ec2.synthetic",
   44     44   
            "CreateNetworkInsightsAccessScopeOutput",
   45     45   
        ),
   46     46   
        ::aws_smithy_schema::ShapeType::Structure,
   47         -
        "network_insights_access_scope_content",
          47  +
        "NetworkInsightsAccessScopeContent",
   48     48   
        1,
   49     49   
    )
   50     50   
    .with_xml_name("networkInsightsAccessScopeContent");
          51  +
static CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_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 CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   52     59   
    CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_SCHEMA_ID,
   53     60   
    ::aws_smithy_schema::ShapeType::Structure,
   54     61   
    &[
   55     62   
        &CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE,
   56     63   
        &CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_CONTENT,
          64  +
        &CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_MEMBER__REQUEST_ID,
   57     65   
    ],
   58     66   
);
   59     67   
impl CreateNetworkInsightsAccessScopeOutput {
   60     68   
    /// The schema for this shape.
   61     69   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_SCHEMA;
   62     70   
}
   63     71   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateNetworkInsightsAccessScopeOutput {
   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.network_insights_access_scope {
   70     78   
            ser.write_struct(&CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE, val)?;
   71     79   
        }
   72     80   
        if let Some(ref val) = self.network_insights_access_scope_content {
   73     81   
            ser.write_struct(&CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_CONTENT, val)?;
   74     82   
        }
   75     83   
        Ok(())
   76     84   
    }
   77     85   
}
   78     86   
impl CreateNetworkInsightsAccessScopeOutput {
   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(&CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_SCHEMA, (), |_, member, deser| {
         100  +
        deserializer.read_struct(&CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_SCHEMA, &mut |member, deser| {
         101  +
            match member.member_index() {
         102  +
                Some(0) => {
         103  +
                    builder.network_insights_access_scope = Some(crate::types::NetworkInsightsAccessScope::deserialize(deser)?);
         104  +
                }
         105  +
                Some(1) => {
         106  +
                    builder.network_insights_access_scope_content = Some(crate::types::NetworkInsightsAccessScopeContent::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 CreateNetworkInsightsAccessScopeOutput {
         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(&CREATENETWORKINSIGHTSACCESSSCOPEOUTPUT_SCHEMA, &mut |member, deser| {
   93    141   
            match member.member_index() {
   94    142   
                Some(0) => {
   95    143   
                    builder.network_insights_access_scope = Some(crate::types::NetworkInsightsAccessScope::deserialize(deser)?);
   96    144   
                }
   97    145   
                Some(1) => {
   98    146   
                    builder.network_insights_access_scope_content = Some(crate::types::NetworkInsightsAccessScopeContent::deserialize(deser)?);
   99    147   
                }
  100    148   
                _ => {}
  101    149   
            }
  102    150   
            Ok(())

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_insights_path.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 `CreateNetworkInsightsPath`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CreateNetworkInsightsPath;
    6      6   
impl CreateNetworkInsightsPath {
    7      7   
    /// Creates a new `CreateNetworkInsightsPath`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::create_network_insights_path::CreateNetworkInsightsPathInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::create_network_insights_path::CreateNetworkInsightsPathOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::create_network_insights_path::CreateNetworkInsightsPathInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::create_network_insights_path::CreateNetworkInsightsPathOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::create_network_insights_path::CreateNetworkInsightsPathError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -126,132 +188,195 @@
  146    152   
                crate::operation::create_network_insights_path::CreateNetworkInsightsPathError,
  147    153   
            >::new());
  148    154   
  149    155   
        ::std::borrow::Cow::Owned(rcb)
  150    156   
    }
  151    157   
}
  152    158   
  153    159   
#[derive(Debug)]
  154    160   
struct CreateNetworkInsightsPathResponseDeserializer;
  155    161   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateNetworkInsightsPathResponseDeserializer {
  156         -
    fn deserialize_nonstreaming(
         162  +
    fn deserialize_nonstreaming_with_config(
  157    163   
        &self,
  158    164   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         165  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  159    166   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  160    167   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  161    168   
        let headers = response.headers();
  162    169   
        let body = response.body().bytes().expect("body loaded");
  163    170   
        #[allow(unused_mut)]
  164    171   
        let mut force_error = false;
  165    172   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  166    173   
        let parse_result = if !success && status != 200 || force_error {
  167    174   
            crate::protocol_serde::shape_create_network_insights_path::de_create_network_insights_path_http_error(status, headers, body)
  168    175   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_insights_path/_create_network_insights_path_input.rs

@@ -59,59 +220,220 @@
   79     79   
    "com.amazonaws.ec2.synthetic",
   80     80   
    "CreateNetworkInsightsPathInput",
   81     81   
);
   82     82   
static CREATENETWORKINSIGHTSPATHINPUT_MEMBER_SOURCE_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsPathInput$SourceIp",
   85     85   
        "com.amazonaws.ec2.synthetic",
   86     86   
        "CreateNetworkInsightsPathInput",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "source_ip",
          89  +
    "SourceIp",
   90     90   
    0,
   91     91   
);
   92     92   
static CREATENETWORKINSIGHTSPATHINPUT_MEMBER_DESTINATION_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsPathInput$DestinationIp",
   95     95   
        "com.amazonaws.ec2.synthetic",
   96     96   
        "CreateNetworkInsightsPathInput",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "destination_ip",
          99  +
    "DestinationIp",
  100    100   
    1,
  101    101   
);
  102    102   
static CREATENETWORKINSIGHTSPATHINPUT_MEMBER_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static(
  104    104   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsPathInput$Source",
  105    105   
        "com.amazonaws.ec2.synthetic",
  106    106   
        "CreateNetworkInsightsPathInput",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "source",
         109  +
    "Source",
  110    110   
    2,
  111    111   
);
  112    112   
static CREATENETWORKINSIGHTSPATHINPUT_MEMBER_DESTINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsPathInput$Destination",
  115    115   
        "com.amazonaws.ec2.synthetic",
  116    116   
        "CreateNetworkInsightsPathInput",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::String,
  119         -
    "destination",
         119  +
    "Destination",
  120    120   
    3,
  121    121   
);
  122    122   
static CREATENETWORKINSIGHTSPATHINPUT_MEMBER_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  123    123   
    ::aws_smithy_schema::ShapeId::from_static(
  124    124   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsPathInput$Protocol",
  125    125   
        "com.amazonaws.ec2.synthetic",
  126    126   
        "CreateNetworkInsightsPathInput",
  127    127   
    ),
  128    128   
    ::aws_smithy_schema::ShapeType::String,
  129         -
    "protocol",
         129  +
    "Protocol",
  130    130   
    4,
  131    131   
);
  132    132   
static CREATENETWORKINSIGHTSPATHINPUT_MEMBER_DESTINATION_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  133    133   
    ::aws_smithy_schema::ShapeId::from_static(
  134    134   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsPathInput$DestinationPort",
  135    135   
        "com.amazonaws.ec2.synthetic",
  136    136   
        "CreateNetworkInsightsPathInput",
  137    137   
    ),
  138    138   
    ::aws_smithy_schema::ShapeType::Integer,
  139         -
    "destination_port",
         139  +
    "DestinationPort",
  140    140   
    5,
  141    141   
);
  142    142   
static CREATENETWORKINSIGHTSPATHINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  143    143   
    ::aws_smithy_schema::ShapeId::from_static(
  144    144   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsPathInput$TagSpecifications",
  145    145   
        "com.amazonaws.ec2.synthetic",
  146    146   
        "CreateNetworkInsightsPathInput",
  147    147   
    ),
  148    148   
    ::aws_smithy_schema::ShapeType::List,
  149         -
    "tag_specifications",
         149  +
    "TagSpecifications",
  150    150   
    6,
  151    151   
)
  152    152   
.with_xml_name("TagSpecification");
  153    153   
static CREATENETWORKINSIGHTSPATHINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  154    154   
    ::aws_smithy_schema::ShapeId::from_static(
  155    155   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsPathInput$DryRun",
  156    156   
        "com.amazonaws.ec2.synthetic",
  157    157   
        "CreateNetworkInsightsPathInput",
  158    158   
    ),
  159    159   
    ::aws_smithy_schema::ShapeType::Boolean,
  160         -
    "dry_run",
         160  +
    "DryRun",
  161    161   
    7,
  162    162   
);
  163    163   
static CREATENETWORKINSIGHTSPATHINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  164    164   
    ::aws_smithy_schema::ShapeId::from_static(
  165    165   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsPathInput$ClientToken",
  166    166   
        "com.amazonaws.ec2.synthetic",
  167    167   
        "CreateNetworkInsightsPathInput",
  168    168   
    ),
  169    169   
    ::aws_smithy_schema::ShapeType::String,
  170         -
    "client_token",
         170  +
    "ClientToken",
  171    171   
    8,
  172    172   
);
  173    173   
static CREATENETWORKINSIGHTSPATHINPUT_MEMBER_FILTER_AT_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  174    174   
    ::aws_smithy_schema::ShapeId::from_static(
  175    175   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsPathInput$FilterAtSource",
  176    176   
        "com.amazonaws.ec2.synthetic",
  177    177   
        "CreateNetworkInsightsPathInput",
  178    178   
    ),
  179    179   
    ::aws_smithy_schema::ShapeType::Structure,
  180         -
    "filter_at_source",
         180  +
    "FilterAtSource",
  181    181   
    9,
  182    182   
);
  183    183   
static CREATENETWORKINSIGHTSPATHINPUT_MEMBER_FILTER_AT_DESTINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  184    184   
    ::aws_smithy_schema::ShapeId::from_static(
  185    185   
        "com.amazonaws.ec2.synthetic#CreateNetworkInsightsPathInput$FilterAtDestination",
  186    186   
        "com.amazonaws.ec2.synthetic",
  187    187   
        "CreateNetworkInsightsPathInput",
  188    188   
    ),
  189    189   
    ::aws_smithy_schema::ShapeType::Structure,
  190         -
    "filter_at_destination",
         190  +
    "FilterAtDestination",
  191    191   
    10,
  192    192   
);
  193    193   
static CREATENETWORKINSIGHTSPATHINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  194    194   
    CREATENETWORKINSIGHTSPATHINPUT_SCHEMA_ID,
  195    195   
    ::aws_smithy_schema::ShapeType::Structure,
  196    196   
    &[
  197    197   
        &CREATENETWORKINSIGHTSPATHINPUT_MEMBER_SOURCE_IP,
  198    198   
        &CREATENETWORKINSIGHTSPATHINPUT_MEMBER_DESTINATION_IP,
  199    199   
        &CREATENETWORKINSIGHTSPATHINPUT_MEMBER_SOURCE,
  200    200   
        &CREATENETWORKINSIGHTSPATHINPUT_MEMBER_DESTINATION,
@@ -236,236 +361,371 @@
  256    256   
            ser.write_struct(&CREATENETWORKINSIGHTSPATHINPUT_MEMBER_FILTER_AT_SOURCE, val)?;
  257    257   
        }
  258    258   
        if let Some(ref val) = self.filter_at_destination {
  259    259   
            ser.write_struct(&CREATENETWORKINSIGHTSPATHINPUT_MEMBER_FILTER_AT_DESTINATION, val)?;
  260    260   
        }
  261    261   
        Ok(())
  262    262   
    }
  263    263   
}
  264    264   
impl CreateNetworkInsightsPathInput {
  265    265   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  266         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  267         -
        deserializer: &mut D,
         266  +
    pub fn deserialize(
         267  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  268    268   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  269    269   
        #[allow(unused_variables, unused_mut)]
  270    270   
        let mut builder = Self::builder();
  271    271   
        #[allow(
  272    272   
            unused_variables,
  273    273   
            unreachable_code,
  274    274   
            clippy::single_match,
  275    275   
            clippy::match_single_binding,
  276    276   
            clippy::diverging_sub_expression
  277    277   
        )]
  278         -
        deserializer.read_struct(&CREATENETWORKINSIGHTSPATHINPUT_SCHEMA, (), |_, member, deser| {
         278  +
        deserializer.read_struct(&CREATENETWORKINSIGHTSPATHINPUT_SCHEMA, &mut |member, deser| {
  279    279   
            match member.member_index() {
  280    280   
                Some(0) => {
  281    281   
                    builder.source_ip = Some(deser.read_string(member)?);
  282    282   
                }
  283    283   
                Some(1) => {
  284    284   
                    builder.destination_ip = Some(deser.read_string(member)?);
  285    285   
                }
  286    286   
                Some(2) => {
  287    287   
                    builder.source = Some(deser.read_string(member)?);
  288    288   
                }
  289    289   
                Some(3) => {
  290    290   
                    builder.destination = Some(deser.read_string(member)?);
  291    291   
                }
  292    292   
                Some(4) => {
  293    293   
                    builder.protocol = Some(crate::types::Protocol::from(deser.read_string(member)?.as_str()));
  294    294   
                }
  295    295   
                Some(5) => {
  296    296   
                    builder.destination_port = Some(deser.read_integer(member)?);
  297    297   
                }
  298    298   
                Some(6) => {
  299    299   
                    builder.tag_specifications = Some({
  300         -
                        let container = if let Some(cap) = deser.container_size() {
  301         -
                            Vec::with_capacity(cap)
  302         -
                        } else {
  303         -
                            Vec::new()
  304         -
                        };
  305         -
                        deser.read_list(member, container, |mut list, deser| {
  306         -
                            list.push(crate::types::TagSpecification::deserialize(deser)?);
  307         -
                            Ok(list)
  308         -
                        })?
         300  +
                        let mut container = Vec::new();
         301  +
                        deser.read_list(member, &mut |deser| {
         302  +
                            container.push(crate::types::TagSpecification::deserialize(deser)?);
         303  +
                            Ok(())
         304  +
                        })?;
         305  +
                        container
  309    306   
                    });
  310    307   
                }
  311    308   
                Some(7) => {
  312    309   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  313    310   
                }
  314    311   
                Some(8) => {
  315    312   
                    builder.client_token = Some(deser.read_string(member)?);
  316    313   
                }
  317    314   
                Some(9) => {
  318    315   
                    builder.filter_at_source = Some(crate::types::PathRequestFilter::deserialize(deser)?);
  319    316   
                }
  320    317   
                Some(10) => {
  321    318   
                    builder.filter_at_destination = Some(crate::types::PathRequestFilter::deserialize(deser)?);
  322    319   
                }
  323    320   
                _ => {}
  324    321   
            }
  325    322   
            Ok(())
  326    323   
        })?;
         324  +
        builder.source = builder.source.or(Some(String::new()));
         325  +
        builder.client_token = builder.client_token.or(Some(String::new()));
  327    326   
        builder
  328    327   
            .build()
  329    328   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  330    329   
    }
  331    330   
}
         331  +
impl CreateNetworkInsightsPathInput {
         332  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         333  +
    pub fn deserialize_with_response(
         334  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         335  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         336  +
        _status: u16,
         337  +
        _body: &[u8],
         338  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         339  +
        Self::deserialize(deserializer)
         340  +
    }
         341  +
}
  332    342   
impl CreateNetworkInsightsPathInput {
  333    343   
    /// Creates a new builder-style object to manufacture [`CreateNetworkInsightsPathInput`](crate::operation::create_network_insights_path::CreateNetworkInsightsPathInput).
  334    344   
    pub fn builder() -> crate::operation::create_network_insights_path::builders::CreateNetworkInsightsPathInputBuilder {
  335    345   
        crate::operation::create_network_insights_path::builders::CreateNetworkInsightsPathInputBuilder::default()
  336    346   
    }
  337    347   
}
  338    348   
  339    349   
/// A builder for [`CreateNetworkInsightsPathInput`](crate::operation::create_network_insights_path::CreateNetworkInsightsPathInput).
  340    350   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  341    351   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_insights_path/_create_network_insights_path_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_interface.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 `CreateNetworkInterface`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CreateNetworkInterface;
    6      6   
impl CreateNetworkInterface {
    7      7   
    /// Creates a new `CreateNetworkInterface`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::create_network_interface::CreateNetworkInterfaceInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::create_network_interface::CreateNetworkInterfaceOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::create_network_interface::CreateNetworkInterfaceInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::create_network_interface::CreateNetworkInterfaceOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::create_network_interface::CreateNetworkInterfaceError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -125,129 +187,192 @@
  145    149   
                crate::operation::create_network_interface::CreateNetworkInterfaceError,
  146    150   
            >::new());
  147    151   
  148    152   
        ::std::borrow::Cow::Owned(rcb)
  149    153   
    }
  150    154   
}
  151    155   
  152    156   
#[derive(Debug)]
  153    157   
struct CreateNetworkInterfaceResponseDeserializer;
  154    158   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateNetworkInterfaceResponseDeserializer {
  155         -
    fn deserialize_nonstreaming(
         159  +
    fn deserialize_nonstreaming_with_config(
  156    160   
        &self,
  157    161   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         162  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  158    163   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  159    164   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  160    165   
        let headers = response.headers();
  161    166   
        let body = response.body().bytes().expect("body loaded");
  162    167   
        #[allow(unused_mut)]
  163    168   
        let mut force_error = false;
  164    169   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  165    170   
        let parse_result = if !success && status != 200 || force_error {
  166    171   
            crate::protocol_serde::shape_create_network_interface::de_create_network_interface_http_error(status, headers, body)
  167    172   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_interface/_create_network_interface_input.rs

@@ -139,139 +390,390 @@
  159    159   
    "com.amazonaws.ec2.synthetic",
  160    160   
    "CreateNetworkInterfaceInput",
  161    161   
);
  162    162   
static CREATENETWORKINTERFACEINPUT_MEMBER_IPV4_PREFIXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  163    163   
    ::aws_smithy_schema::ShapeId::from_static(
  164    164   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$Ipv4Prefixes",
  165    165   
        "com.amazonaws.ec2.synthetic",
  166    166   
        "CreateNetworkInterfaceInput",
  167    167   
    ),
  168    168   
    ::aws_smithy_schema::ShapeType::List,
  169         -
    "ipv4_prefixes",
         169  +
    "Ipv4Prefixes",
  170    170   
    0,
  171    171   
)
  172    172   
.with_xml_name("Ipv4Prefix");
  173    173   
static CREATENETWORKINTERFACEINPUT_MEMBER_IPV4_PREFIX_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  174    174   
    ::aws_smithy_schema::ShapeId::from_static(
  175    175   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$Ipv4PrefixCount",
  176    176   
        "com.amazonaws.ec2.synthetic",
  177    177   
        "CreateNetworkInterfaceInput",
  178    178   
    ),
  179    179   
    ::aws_smithy_schema::ShapeType::Integer,
  180         -
    "ipv4_prefix_count",
         180  +
    "Ipv4PrefixCount",
  181    181   
    1,
  182    182   
);
  183    183   
static CREATENETWORKINTERFACEINPUT_MEMBER_IPV6_PREFIXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  184    184   
    ::aws_smithy_schema::ShapeId::from_static(
  185    185   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$Ipv6Prefixes",
  186    186   
        "com.amazonaws.ec2.synthetic",
  187    187   
        "CreateNetworkInterfaceInput",
  188    188   
    ),
  189    189   
    ::aws_smithy_schema::ShapeType::List,
  190         -
    "ipv6_prefixes",
         190  +
    "Ipv6Prefixes",
  191    191   
    2,
  192    192   
)
  193    193   
.with_xml_name("Ipv6Prefix");
  194    194   
static CREATENETWORKINTERFACEINPUT_MEMBER_IPV6_PREFIX_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  195    195   
    ::aws_smithy_schema::ShapeId::from_static(
  196    196   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$Ipv6PrefixCount",
  197    197   
        "com.amazonaws.ec2.synthetic",
  198    198   
        "CreateNetworkInterfaceInput",
  199    199   
    ),
  200    200   
    ::aws_smithy_schema::ShapeType::Integer,
  201         -
    "ipv6_prefix_count",
         201  +
    "Ipv6PrefixCount",
  202    202   
    3,
  203    203   
);
  204    204   
static CREATENETWORKINTERFACEINPUT_MEMBER_INTERFACE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  205    205   
    ::aws_smithy_schema::ShapeId::from_static(
  206    206   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$InterfaceType",
  207    207   
        "com.amazonaws.ec2.synthetic",
  208    208   
        "CreateNetworkInterfaceInput",
  209    209   
    ),
  210    210   
    ::aws_smithy_schema::ShapeType::String,
  211         -
    "interface_type",
         211  +
    "InterfaceType",
  212    212   
    4,
  213    213   
);
  214    214   
static CREATENETWORKINTERFACEINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  215    215   
    ::aws_smithy_schema::ShapeId::from_static(
  216    216   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$TagSpecifications",
  217    217   
        "com.amazonaws.ec2.synthetic",
  218    218   
        "CreateNetworkInterfaceInput",
  219    219   
    ),
  220    220   
    ::aws_smithy_schema::ShapeType::List,
  221         -
    "tag_specifications",
         221  +
    "TagSpecifications",
  222    222   
    5,
  223    223   
)
  224    224   
.with_xml_name("TagSpecification");
  225    225   
static CREATENETWORKINTERFACEINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  226    226   
    ::aws_smithy_schema::ShapeId::from_static(
  227    227   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$ClientToken",
  228    228   
        "com.amazonaws.ec2.synthetic",
  229    229   
        "CreateNetworkInterfaceInput",
  230    230   
    ),
  231    231   
    ::aws_smithy_schema::ShapeType::String,
  232         -
    "client_token",
         232  +
    "ClientToken",
  233    233   
    6,
  234    234   
);
  235    235   
static CREATENETWORKINTERFACEINPUT_MEMBER_ENABLE_PRIMARY_IPV6: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  236    236   
    ::aws_smithy_schema::ShapeId::from_static(
  237    237   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$EnablePrimaryIpv6",
  238    238   
        "com.amazonaws.ec2.synthetic",
  239    239   
        "CreateNetworkInterfaceInput",
  240    240   
    ),
  241    241   
    ::aws_smithy_schema::ShapeType::Boolean,
  242         -
    "enable_primary_ipv6",
         242  +
    "EnablePrimaryIpv6",
  243    243   
    7,
  244    244   
);
  245    245   
static CREATENETWORKINTERFACEINPUT_MEMBER_CONNECTION_TRACKING_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  246    246   
    ::aws_smithy_schema::ShapeId::from_static(
  247    247   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$ConnectionTrackingSpecification",
  248    248   
        "com.amazonaws.ec2.synthetic",
  249    249   
        "CreateNetworkInterfaceInput",
  250    250   
    ),
  251    251   
    ::aws_smithy_schema::ShapeType::Structure,
  252         -
    "connection_tracking_specification",
         252  +
    "ConnectionTrackingSpecification",
  253    253   
    8,
  254    254   
);
  255    255   
static CREATENETWORKINTERFACEINPUT_MEMBER_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  256    256   
    ::aws_smithy_schema::ShapeId::from_static(
  257    257   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$Operator",
  258    258   
        "com.amazonaws.ec2.synthetic",
  259    259   
        "CreateNetworkInterfaceInput",
  260    260   
    ),
  261    261   
    ::aws_smithy_schema::ShapeType::Structure,
  262         -
    "operator",
         262  +
    "Operator",
  263    263   
    9,
  264    264   
);
  265    265   
static CREATENETWORKINTERFACEINPUT_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  266    266   
    ::aws_smithy_schema::ShapeId::from_static(
  267    267   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$SubnetId",
  268    268   
        "com.amazonaws.ec2.synthetic",
  269    269   
        "CreateNetworkInterfaceInput",
  270    270   
    ),
  271    271   
    ::aws_smithy_schema::ShapeType::String,
  272         -
    "subnet_id",
         272  +
    "SubnetId",
  273    273   
    10,
  274    274   
)
  275    275   
.with_xml_name("subnetId");
  276    276   
static CREATENETWORKINTERFACEINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  277    277   
    ::aws_smithy_schema::ShapeId::from_static(
  278    278   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$Description",
  279    279   
        "com.amazonaws.ec2.synthetic",
  280    280   
        "CreateNetworkInterfaceInput",
  281    281   
    ),
  282    282   
    ::aws_smithy_schema::ShapeType::String,
  283         -
    "description",
         283  +
    "Description",
  284    284   
    11,
  285    285   
)
  286    286   
.with_xml_name("description");
  287    287   
static CREATENETWORKINTERFACEINPUT_MEMBER_PRIVATE_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  288    288   
    ::aws_smithy_schema::ShapeId::from_static(
  289    289   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$PrivateIpAddress",
  290    290   
        "com.amazonaws.ec2.synthetic",
  291    291   
        "CreateNetworkInterfaceInput",
  292    292   
    ),
  293    293   
    ::aws_smithy_schema::ShapeType::String,
  294         -
    "private_ip_address",
         294  +
    "PrivateIpAddress",
  295    295   
    12,
  296    296   
)
  297    297   
.with_xml_name("privateIpAddress");
  298    298   
static CREATENETWORKINTERFACEINPUT_MEMBER_GROUPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  299    299   
    ::aws_smithy_schema::ShapeId::from_static(
  300    300   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$Groups",
  301    301   
        "com.amazonaws.ec2.synthetic",
  302    302   
        "CreateNetworkInterfaceInput",
  303    303   
    ),
  304    304   
    ::aws_smithy_schema::ShapeType::List,
  305         -
    "groups",
         305  +
    "Groups",
  306    306   
    13,
  307    307   
)
  308    308   
.with_xml_name("SecurityGroupId");
  309    309   
static CREATENETWORKINTERFACEINPUT_MEMBER_PRIVATE_IP_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  310    310   
    ::aws_smithy_schema::ShapeId::from_static(
  311    311   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$PrivateIpAddresses",
  312    312   
        "com.amazonaws.ec2.synthetic",
  313    313   
        "CreateNetworkInterfaceInput",
  314    314   
    ),
  315    315   
    ::aws_smithy_schema::ShapeType::List,
  316         -
    "private_ip_addresses",
         316  +
    "PrivateIpAddresses",
  317    317   
    14,
  318    318   
)
  319    319   
.with_xml_name("privateIpAddresses");
  320    320   
static CREATENETWORKINTERFACEINPUT_MEMBER_SECONDARY_PRIVATE_IP_ADDRESS_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  321    321   
    ::aws_smithy_schema::ShapeId::from_static(
  322    322   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$SecondaryPrivateIpAddressCount",
  323    323   
        "com.amazonaws.ec2.synthetic",
  324    324   
        "CreateNetworkInterfaceInput",
  325    325   
    ),
  326    326   
    ::aws_smithy_schema::ShapeType::Integer,
  327         -
    "secondary_private_ip_address_count",
         327  +
    "SecondaryPrivateIpAddressCount",
  328    328   
    15,
  329    329   
)
  330    330   
.with_xml_name("secondaryPrivateIpAddressCount");
  331    331   
static CREATENETWORKINTERFACEINPUT_MEMBER_IPV6_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  332    332   
    ::aws_smithy_schema::ShapeId::from_static(
  333    333   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$Ipv6Addresses",
  334    334   
        "com.amazonaws.ec2.synthetic",
  335    335   
        "CreateNetworkInterfaceInput",
  336    336   
    ),
  337    337   
    ::aws_smithy_schema::ShapeType::List,
  338         -
    "ipv6_addresses",
         338  +
    "Ipv6Addresses",
  339    339   
    16,
  340    340   
)
  341    341   
.with_xml_name("ipv6Addresses");
  342    342   
static CREATENETWORKINTERFACEINPUT_MEMBER_IPV6_ADDRESS_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  343    343   
    ::aws_smithy_schema::ShapeId::from_static(
  344    344   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$Ipv6AddressCount",
  345    345   
        "com.amazonaws.ec2.synthetic",
  346    346   
        "CreateNetworkInterfaceInput",
  347    347   
    ),
  348    348   
    ::aws_smithy_schema::ShapeType::Integer,
  349         -
    "ipv6_address_count",
         349  +
    "Ipv6AddressCount",
  350    350   
    17,
  351    351   
)
  352    352   
.with_xml_name("ipv6AddressCount");
  353    353   
static CREATENETWORKINTERFACEINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  354    354   
    ::aws_smithy_schema::ShapeId::from_static(
  355    355   
        "com.amazonaws.ec2.synthetic#CreateNetworkInterfaceInput$DryRun",
  356    356   
        "com.amazonaws.ec2.synthetic",
  357    357   
        "CreateNetworkInterfaceInput",
  358    358   
    ),
  359    359   
    ::aws_smithy_schema::ShapeType::Boolean,
  360         -
    "dry_run",
         360  +
    "DryRun",
  361    361   
    18,
  362    362   
)
  363    363   
.with_xml_name("dryRun");
  364    364   
static CREATENETWORKINTERFACEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  365    365   
    CREATENETWORKINTERFACEINPUT_SCHEMA_ID,
  366    366   
    ::aws_smithy_schema::ShapeType::Structure,
  367    367   
    &[
  368    368   
        &CREATENETWORKINTERFACEINPUT_MEMBER_IPV4_PREFIXES,
  369    369   
        &CREATENETWORKINTERFACEINPUT_MEMBER_IPV4_PREFIX_COUNT,
  370    370   
        &CREATENETWORKINTERFACEINPUT_MEMBER_IPV6_PREFIXES,
@@ -479,479 +678,665 @@
  499    499   
            ser.write_integer(&CREATENETWORKINTERFACEINPUT_MEMBER_IPV6_ADDRESS_COUNT, *val)?;
  500    500   
        }
  501    501   
        if let Some(ref val) = self.dry_run {
  502    502   
            ser.write_boolean(&CREATENETWORKINTERFACEINPUT_MEMBER_DRY_RUN, *val)?;
  503    503   
        }
  504    504   
        Ok(())
  505    505   
    }
  506    506   
}
  507    507   
impl CreateNetworkInterfaceInput {
  508    508   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  509         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  510         -
        deserializer: &mut D,
         509  +
    pub fn deserialize(
         510  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  511    511   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  512    512   
        #[allow(unused_variables, unused_mut)]
  513    513   
        let mut builder = Self::builder();
  514    514   
        #[allow(
  515    515   
            unused_variables,
  516    516   
            unreachable_code,
  517    517   
            clippy::single_match,
  518    518   
            clippy::match_single_binding,
  519    519   
            clippy::diverging_sub_expression
  520    520   
        )]
  521         -
        deserializer.read_struct(&CREATENETWORKINTERFACEINPUT_SCHEMA, (), |_, member, deser| {
         521  +
        deserializer.read_struct(&CREATENETWORKINTERFACEINPUT_SCHEMA, &mut |member, deser| {
  522    522   
            match member.member_index() {
  523    523   
                Some(0) => {
  524    524   
                    builder.ipv4_prefixes = Some({
  525         -
                        let container = if let Some(cap) = deser.container_size() {
  526         -
                            Vec::with_capacity(cap)
  527         -
                        } else {
  528         -
                            Vec::new()
  529         -
                        };
  530         -
                        deser.read_list(member, container, |mut list, deser| {
  531         -
                            list.push(crate::types::Ipv4PrefixSpecificationRequest::deserialize(deser)?);
  532         -
                            Ok(list)
  533         -
                        })?
         525  +
                        let mut container = Vec::new();
         526  +
                        deser.read_list(member, &mut |deser| {
         527  +
                            container.push(crate::types::Ipv4PrefixSpecificationRequest::deserialize(deser)?);
         528  +
                            Ok(())
         529  +
                        })?;
         530  +
                        container
  534    531   
                    });
  535    532   
                }
  536    533   
                Some(1) => {
  537    534   
                    builder.ipv4_prefix_count = Some(deser.read_integer(member)?);
  538    535   
                }
  539    536   
                Some(2) => {
  540    537   
                    builder.ipv6_prefixes = Some({
  541         -
                        let container = if let Some(cap) = deser.container_size() {
  542         -
                            Vec::with_capacity(cap)
  543         -
                        } else {
  544         -
                            Vec::new()
  545         -
                        };
  546         -
                        deser.read_list(member, container, |mut list, deser| {
  547         -
                            list.push(crate::types::Ipv6PrefixSpecificationRequest::deserialize(deser)?);
  548         -
                            Ok(list)
  549         -
                        })?
         538  +
                        let mut container = Vec::new();
         539  +
                        deser.read_list(member, &mut |deser| {
         540  +
                            container.push(crate::types::Ipv6PrefixSpecificationRequest::deserialize(deser)?);
         541  +
                            Ok(())
         542  +
                        })?;
         543  +
                        container
  550    544   
                    });
  551    545   
                }
  552    546   
                Some(3) => {
  553    547   
                    builder.ipv6_prefix_count = Some(deser.read_integer(member)?);
  554    548   
                }
  555    549   
                Some(4) => {
  556    550   
                    builder.interface_type = Some(crate::types::NetworkInterfaceCreationType::from(deser.read_string(member)?.as_str()));
  557    551   
                }
  558    552   
                Some(5) => {
  559    553   
                    builder.tag_specifications = Some({
  560         -
                        let container = if let Some(cap) = deser.container_size() {
  561         -
                            Vec::with_capacity(cap)
  562         -
                        } else {
  563         -
                            Vec::new()
  564         -
                        };
  565         -
                        deser.read_list(member, container, |mut list, deser| {
  566         -
                            list.push(crate::types::TagSpecification::deserialize(deser)?);
  567         -
                            Ok(list)
  568         -
                        })?
         554  +
                        let mut container = Vec::new();
         555  +
                        deser.read_list(member, &mut |deser| {
         556  +
                            container.push(crate::types::TagSpecification::deserialize(deser)?);
         557  +
                            Ok(())
         558  +
                        })?;
         559  +
                        container
  569    560   
                    });
  570    561   
                }
  571    562   
                Some(6) => {
  572    563   
                    builder.client_token = Some(deser.read_string(member)?);
  573    564   
                }
  574    565   
                Some(7) => {
  575    566   
                    builder.enable_primary_ipv6 = Some(deser.read_boolean(member)?);
  576    567   
                }
  577    568   
                Some(8) => {
  578    569   
                    builder.connection_tracking_specification = Some(crate::types::ConnectionTrackingSpecificationRequest::deserialize(deser)?);
  579    570   
                }
  580    571   
                Some(9) => {
  581    572   
                    builder.operator = Some(crate::types::OperatorRequest::deserialize(deser)?);
  582    573   
                }
  583    574   
                Some(10) => {
  584    575   
                    builder.subnet_id = Some(deser.read_string(member)?);
  585    576   
                }
  586    577   
                Some(11) => {
  587    578   
                    builder.description = Some(deser.read_string(member)?);
  588    579   
                }
  589    580   
                Some(12) => {
  590    581   
                    builder.private_ip_address = Some(deser.read_string(member)?);
  591    582   
                }
  592    583   
                Some(13) => {
  593         -
                    builder.groups = Some({
  594         -
                        let container = if let Some(cap) = deser.container_size() {
  595         -
                            Vec::with_capacity(cap)
  596         -
                        } else {
  597         -
                            Vec::new()
  598         -
                        };
  599         -
                        deser.read_list(member, container, |mut list, deser| {
  600         -
                            list.push(deser.read_string(member)?);
  601         -
                            Ok(list)
  602         -
                        })?
  603         -
                    });
         584  +
                    builder.groups = Some(deser.read_string_list(member)?);
  604    585   
                }
  605    586   
                Some(14) => {
  606    587   
                    builder.private_ip_addresses = Some({
  607         -
                        let container = if let Some(cap) = deser.container_size() {
  608         -
                            Vec::with_capacity(cap)
  609         -
                        } else {
  610         -
                            Vec::new()
  611         -
                        };
  612         -
                        deser.read_list(member, container, |mut list, deser| {
  613         -
                            list.push(crate::types::PrivateIpAddressSpecification::deserialize(deser)?);
  614         -
                            Ok(list)
  615         -
                        })?
         588  +
                        let mut container = Vec::new();
         589  +
                        deser.read_list(member, &mut |deser| {
         590  +
                            container.push(crate::types::PrivateIpAddressSpecification::deserialize(deser)?);
         591  +
                            Ok(())
         592  +
                        })?;
         593  +
                        container
  616    594   
                    });
  617    595   
                }
  618    596   
                Some(15) => {
  619    597   
                    builder.secondary_private_ip_address_count = Some(deser.read_integer(member)?);
  620    598   
                }
  621    599   
                Some(16) => {
  622    600   
                    builder.ipv6_addresses = Some({
  623         -
                        let container = if let Some(cap) = deser.container_size() {
  624         -
                            Vec::with_capacity(cap)
  625         -
                        } else {
  626         -
                            Vec::new()
  627         -
                        };
  628         -
                        deser.read_list(member, container, |mut list, deser| {
  629         -
                            list.push(crate::types::InstanceIpv6Address::deserialize(deser)?);
  630         -
                            Ok(list)
  631         -
                        })?
         601  +
                        let mut container = Vec::new();
         602  +
                        deser.read_list(member, &mut |deser| {
         603  +
                            container.push(crate::types::InstanceIpv6Address::deserialize(deser)?);
         604  +
                            Ok(())
         605  +
                        })?;
         606  +
                        container
  632    607   
                    });
  633    608   
                }
  634    609   
                Some(17) => {
  635    610   
                    builder.ipv6_address_count = Some(deser.read_integer(member)?);
  636    611   
                }
  637    612   
                Some(18) => {
  638    613   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  639    614   
                }
  640    615   
                _ => {}
  641    616   
            }
  642    617   
            Ok(())
  643    618   
        })?;
         619  +
        builder.subnet_id = builder.subnet_id.or(Some(String::new()));
  644    620   
        builder
  645    621   
            .build()
  646    622   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  647    623   
    }
  648    624   
}
         625  +
impl CreateNetworkInterfaceInput {
         626  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         627  +
    pub fn deserialize_with_response(
         628  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         629  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         630  +
        _status: u16,
         631  +
        _body: &[u8],
         632  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         633  +
        Self::deserialize(deserializer)
         634  +
    }
         635  +
}
  649    636   
impl CreateNetworkInterfaceInput {
  650    637   
    /// Creates a new builder-style object to manufacture [`CreateNetworkInterfaceInput`](crate::operation::create_network_interface::CreateNetworkInterfaceInput).
  651    638   
    pub fn builder() -> crate::operation::create_network_interface::builders::CreateNetworkInterfaceInputBuilder {
  652    639   
        crate::operation::create_network_interface::builders::CreateNetworkInterfaceInputBuilder::default()
  653    640   
    }
  654    641   
}
  655    642   
  656    643   
/// A builder for [`CreateNetworkInterfaceInput`](crate::operation::create_network_interface::CreateNetworkInterfaceInput).
  657    644   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  658    645   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_interface/_create_network_interface_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_interface_permission.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 `CreateNetworkInterfacePermission`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CreateNetworkInterfacePermission;
    6      6   
impl CreateNetworkInterfacePermission {
    7      7   
    /// Creates a new `CreateNetworkInterfacePermission`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::create_network_interface_permission::CreateNetworkInterfacePermissionInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::create_network_interface_permission::CreateNetworkInterfacePermissionOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::create_network_interface_permission::CreateNetworkInterfacePermissionInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::create_network_interface_permission::CreateNetworkInterfacePermissionOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::create_network_interface_permission::CreateNetworkInterfacePermissionError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +186,193 @@
  144    150   
                crate::operation::create_network_interface_permission::CreateNetworkInterfacePermissionError,
  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 CreateNetworkInterfacePermissionResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateNetworkInterfacePermissionResponseDeserializer {
  154         -
    fn deserialize_nonstreaming(
         160  +
    fn deserialize_nonstreaming_with_config(
  155    161   
        &self,
  156    162   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         163  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  157    164   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  158    165   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  159    166   
        let headers = response.headers();
  160    167   
        let body = response.body().bytes().expect("body loaded");
  161    168   
        #[allow(unused_mut)]
  162    169   
        let mut force_error = false;
  163    170   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  164    171   
        let parse_result = if !success && status != 200 || force_error {
  165    172   
            crate::protocol_serde::shape_create_network_interface_permission::de_create_network_interface_permission_http_error(status, headers, body)
  166    173   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_interface_permission/_create_network_interface_permission_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/create_network_interface_permission/_create_network_interface_permission_output.rs

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