AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_bandwidth_gbps_request.rs

@@ -6,6 +131,142 @@
   26     26   
    "com.amazonaws.ec2",
   27     27   
    "NetworkBandwidthGbpsRequest",
   28     28   
);
   29     29   
static NETWORKBANDWIDTHGBPSREQUEST_MEMBER_MIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static(
   31     31   
        "com.amazonaws.ec2#NetworkBandwidthGbpsRequest$Min",
   32     32   
        "com.amazonaws.ec2",
   33     33   
        "NetworkBandwidthGbpsRequest",
   34     34   
    ),
   35     35   
    ::aws_smithy_schema::ShapeType::Double,
   36         -
    "min",
          36  +
    "Min",
   37     37   
    0,
   38     38   
);
   39     39   
static NETWORKBANDWIDTHGBPSREQUEST_MEMBER_MAX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.ec2#NetworkBandwidthGbpsRequest$Max",
   42     42   
        "com.amazonaws.ec2",
   43     43   
        "NetworkBandwidthGbpsRequest",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::Double,
   46         -
    "max",
          46  +
    "Max",
   47     47   
    1,
   48     48   
);
   49     49   
static NETWORKBANDWIDTHGBPSREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    NETWORKBANDWIDTHGBPSREQUEST_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[&NETWORKBANDWIDTHGBPSREQUEST_MEMBER_MIN, &NETWORKBANDWIDTHGBPSREQUEST_MEMBER_MAX],
   53     53   
);
   54     54   
impl NetworkBandwidthGbpsRequest {
   55     55   
    /// The schema for this shape.
   56     56   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NETWORKBANDWIDTHGBPSREQUEST_SCHEMA;
   57     57   
}
   58     58   
impl ::aws_smithy_schema::serde::SerializableStruct for NetworkBandwidthGbpsRequest {
   59     59   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   60     60   
    fn serialize_members(
   61     61   
        &self,
   62     62   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   63     63   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   64     64   
        if let Some(ref val) = self.min {
   65     65   
            ser.write_double(&NETWORKBANDWIDTHGBPSREQUEST_MEMBER_MIN, *val)?;
   66     66   
        }
   67     67   
        if let Some(ref val) = self.max {
   68     68   
            ser.write_double(&NETWORKBANDWIDTHGBPSREQUEST_MEMBER_MAX, *val)?;
   69     69   
        }
   70     70   
        Ok(())
   71     71   
    }
   72     72   
}
   73     73   
impl NetworkBandwidthGbpsRequest {
   74     74   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   75         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   76         -
        deserializer: &mut D,
          75  +
    pub fn deserialize(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   77     77   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   78     78   
        #[allow(unused_variables, unused_mut)]
   79     79   
        let mut builder = Self::builder();
   80     80   
        #[allow(
   81     81   
            unused_variables,
   82     82   
            unreachable_code,
   83     83   
            clippy::single_match,
   84     84   
            clippy::match_single_binding,
   85     85   
            clippy::diverging_sub_expression
   86     86   
        )]
   87         -
        deserializer.read_struct(&NETWORKBANDWIDTHGBPSREQUEST_SCHEMA, (), |_, member, deser| {
          87  +
        deserializer.read_struct(&NETWORKBANDWIDTHGBPSREQUEST_SCHEMA, &mut |member, deser| {
   88     88   
            match member.member_index() {
   89     89   
                Some(0) => {
   90     90   
                    builder.min = Some(deser.read_double(member)?);
   91     91   
                }
   92     92   
                Some(1) => {
   93     93   
                    builder.max = Some(deser.read_double(member)?);
   94     94   
                }
   95     95   
                _ => {}
   96     96   
            }
   97     97   
            Ok(())
   98     98   
        })?;
   99     99   
        Ok(builder.build())
  100    100   
    }
  101    101   
}
         102  +
impl NetworkBandwidthGbpsRequest {
         103  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         104  +
    pub fn deserialize_with_response(
         105  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         106  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         107  +
        _status: u16,
         108  +
        _body: &[u8],
         109  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         110  +
        Self::deserialize(deserializer)
         111  +
    }
         112  +
}
  102    113   
impl NetworkBandwidthGbpsRequest {
  103    114   
    /// Creates a new builder-style object to manufacture [`NetworkBandwidthGbpsRequest`](crate::types::NetworkBandwidthGbpsRequest).
  104    115   
    pub fn builder() -> crate::types::builders::NetworkBandwidthGbpsRequestBuilder {
  105    116   
        crate::types::builders::NetworkBandwidthGbpsRequestBuilder::default()
  106    117   
    }
  107    118   
}
  108    119   
  109    120   
/// A builder for [`NetworkBandwidthGbpsRequest`](crate::types::NetworkBandwidthGbpsRequest).
  110    121   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  111    122   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_card_info.rs

@@ -37,37 +275,286 @@
   57     57   
}
   58     58   
static NETWORKCARDINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   59     59   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkCardInfo", "com.amazonaws.ec2", "NetworkCardInfo");
   60     60   
static NETWORKCARDINFO_MEMBER_NETWORK_CARD_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.ec2#NetworkCardInfo$NetworkCardIndex",
   63     63   
        "com.amazonaws.ec2",
   64     64   
        "NetworkCardInfo",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::Integer,
   67         -
    "network_card_index",
          67  +
    "NetworkCardIndex",
   68     68   
    0,
   69     69   
)
   70     70   
.with_xml_name("networkCardIndex");
   71     71   
static NETWORKCARDINFO_MEMBER_NETWORK_PERFORMANCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.ec2#NetworkCardInfo$NetworkPerformance",
   74     74   
        "com.amazonaws.ec2",
   75     75   
        "NetworkCardInfo",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::String,
   78         -
    "network_performance",
          78  +
    "NetworkPerformance",
   79     79   
    1,
   80     80   
)
   81     81   
.with_xml_name("networkPerformance");
   82     82   
static NETWORKCARDINFO_MEMBER_MAXIMUM_NETWORK_INTERFACES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.ec2#NetworkCardInfo$MaximumNetworkInterfaces",
   85     85   
        "com.amazonaws.ec2",
   86     86   
        "NetworkCardInfo",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::Integer,
   89         -
    "maximum_network_interfaces",
          89  +
    "MaximumNetworkInterfaces",
   90     90   
    2,
   91     91   
)
   92     92   
.with_xml_name("maximumNetworkInterfaces");
   93     93   
static NETWORKCARDINFO_MEMBER_BASELINE_BANDWIDTH_IN_GBPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.ec2#NetworkCardInfo$BaselineBandwidthInGbps",
   96     96   
        "com.amazonaws.ec2",
   97     97   
        "NetworkCardInfo",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::Double,
  100         -
    "baseline_bandwidth_in_gbps",
         100  +
    "BaselineBandwidthInGbps",
  101    101   
    3,
  102    102   
)
  103    103   
.with_xml_name("baselineBandwidthInGbps");
  104    104   
static NETWORKCARDINFO_MEMBER_PEAK_BANDWIDTH_IN_GBPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static(
  106    106   
        "com.amazonaws.ec2#NetworkCardInfo$PeakBandwidthInGbps",
  107    107   
        "com.amazonaws.ec2",
  108    108   
        "NetworkCardInfo",
  109    109   
    ),
  110    110   
    ::aws_smithy_schema::ShapeType::Double,
  111         -
    "peak_bandwidth_in_gbps",
         111  +
    "PeakBandwidthInGbps",
  112    112   
    4,
  113    113   
)
  114    114   
.with_xml_name("peakBandwidthInGbps");
  115    115   
static NETWORKCARDINFO_MEMBER_DEFAULT_ENA_QUEUE_COUNT_PER_INTERFACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static(
  117    117   
        "com.amazonaws.ec2#NetworkCardInfo$DefaultEnaQueueCountPerInterface",
  118    118   
        "com.amazonaws.ec2",
  119    119   
        "NetworkCardInfo",
  120    120   
    ),
  121    121   
    ::aws_smithy_schema::ShapeType::Integer,
  122         -
    "default_ena_queue_count_per_interface",
         122  +
    "DefaultEnaQueueCountPerInterface",
  123    123   
    5,
  124    124   
)
  125    125   
.with_xml_name("defaultEnaQueueCountPerInterface");
  126    126   
static NETWORKCARDINFO_MEMBER_MAXIMUM_ENA_QUEUE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  127    127   
    ::aws_smithy_schema::ShapeId::from_static(
  128    128   
        "com.amazonaws.ec2#NetworkCardInfo$MaximumEnaQueueCount",
  129    129   
        "com.amazonaws.ec2",
  130    130   
        "NetworkCardInfo",
  131    131   
    ),
  132    132   
    ::aws_smithy_schema::ShapeType::Integer,
  133         -
    "maximum_ena_queue_count",
         133  +
    "MaximumEnaQueueCount",
  134    134   
    6,
  135    135   
)
  136    136   
.with_xml_name("maximumEnaQueueCount");
  137    137   
static NETWORKCARDINFO_MEMBER_MAXIMUM_ENA_QUEUE_COUNT_PER_INTERFACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static(
  139    139   
        "com.amazonaws.ec2#NetworkCardInfo$MaximumEnaQueueCountPerInterface",
  140    140   
        "com.amazonaws.ec2",
  141    141   
        "NetworkCardInfo",
  142    142   
    ),
  143    143   
    ::aws_smithy_schema::ShapeType::Integer,
  144         -
    "maximum_ena_queue_count_per_interface",
         144  +
    "MaximumEnaQueueCountPerInterface",
  145    145   
    7,
  146    146   
)
  147    147   
.with_xml_name("maximumEnaQueueCountPerInterface");
  148    148   
static NETWORKCARDINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  149    149   
    NETWORKCARDINFO_SCHEMA_ID,
  150    150   
    ::aws_smithy_schema::ShapeType::Structure,
  151    151   
    &[
  152    152   
        &NETWORKCARDINFO_MEMBER_NETWORK_CARD_INDEX,
  153    153   
        &NETWORKCARDINFO_MEMBER_NETWORK_PERFORMANCE,
  154    154   
        &NETWORKCARDINFO_MEMBER_MAXIMUM_NETWORK_INTERFACES,
  155    155   
        &NETWORKCARDINFO_MEMBER_BASELINE_BANDWIDTH_IN_GBPS,
  156    156   
        &NETWORKCARDINFO_MEMBER_PEAK_BANDWIDTH_IN_GBPS,
  157    157   
        &NETWORKCARDINFO_MEMBER_DEFAULT_ENA_QUEUE_COUNT_PER_INTERFACE,
  158    158   
        &NETWORKCARDINFO_MEMBER_MAXIMUM_ENA_QUEUE_COUNT,
  159    159   
        &NETWORKCARDINFO_MEMBER_MAXIMUM_ENA_QUEUE_COUNT_PER_INTERFACE,
  160    160   
    ],
  161    161   
);
  162    162   
impl NetworkCardInfo {
  163    163   
    /// The schema for this shape.
  164    164   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NETWORKCARDINFO_SCHEMA;
  165    165   
}
  166    166   
impl ::aws_smithy_schema::serde::SerializableStruct for NetworkCardInfo {
  167    167   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  168    168   
    fn serialize_members(
  169    169   
        &self,
  170    170   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  171    171   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  172    172   
        if let Some(ref val) = self.network_card_index {
  173    173   
            ser.write_integer(&NETWORKCARDINFO_MEMBER_NETWORK_CARD_INDEX, *val)?;
  174    174   
        }
  175    175   
        if let Some(ref val) = self.network_performance {
  176    176   
            ser.write_string(&NETWORKCARDINFO_MEMBER_NETWORK_PERFORMANCE, val)?;
  177    177   
        }
  178    178   
        if let Some(ref val) = self.maximum_network_interfaces {
  179    179   
            ser.write_integer(&NETWORKCARDINFO_MEMBER_MAXIMUM_NETWORK_INTERFACES, *val)?;
  180    180   
        }
  181    181   
        if let Some(ref val) = self.baseline_bandwidth_in_gbps {
  182    182   
            ser.write_double(&NETWORKCARDINFO_MEMBER_BASELINE_BANDWIDTH_IN_GBPS, *val)?;
  183    183   
        }
  184    184   
        if let Some(ref val) = self.peak_bandwidth_in_gbps {
  185    185   
            ser.write_double(&NETWORKCARDINFO_MEMBER_PEAK_BANDWIDTH_IN_GBPS, *val)?;
  186    186   
        }
  187    187   
        if let Some(ref val) = self.default_ena_queue_count_per_interface {
  188    188   
            ser.write_integer(&NETWORKCARDINFO_MEMBER_DEFAULT_ENA_QUEUE_COUNT_PER_INTERFACE, *val)?;
  189    189   
        }
  190    190   
        if let Some(ref val) = self.maximum_ena_queue_count {
  191    191   
            ser.write_integer(&NETWORKCARDINFO_MEMBER_MAXIMUM_ENA_QUEUE_COUNT, *val)?;
  192    192   
        }
  193    193   
        if let Some(ref val) = self.maximum_ena_queue_count_per_interface {
  194    194   
            ser.write_integer(&NETWORKCARDINFO_MEMBER_MAXIMUM_ENA_QUEUE_COUNT_PER_INTERFACE, *val)?;
  195    195   
        }
  196    196   
        Ok(())
  197    197   
    }
  198    198   
}
  199    199   
impl NetworkCardInfo {
  200    200   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  201         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  202         -
        deserializer: &mut D,
         201  +
    pub fn deserialize(
         202  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  203    203   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  204    204   
        #[allow(unused_variables, unused_mut)]
  205    205   
        let mut builder = Self::builder();
  206    206   
        #[allow(
  207    207   
            unused_variables,
  208    208   
            unreachable_code,
  209    209   
            clippy::single_match,
  210    210   
            clippy::match_single_binding,
  211    211   
            clippy::diverging_sub_expression
  212    212   
        )]
  213         -
        deserializer.read_struct(&NETWORKCARDINFO_SCHEMA, (), |_, member, deser| {
         213  +
        deserializer.read_struct(&NETWORKCARDINFO_SCHEMA, &mut |member, deser| {
  214    214   
            match member.member_index() {
  215    215   
                Some(0) => {
  216    216   
                    builder.network_card_index = Some(deser.read_integer(member)?);
  217    217   
                }
  218    218   
                Some(1) => {
  219    219   
                    builder.network_performance = Some(deser.read_string(member)?);
  220    220   
                }
  221    221   
                Some(2) => {
  222    222   
                    builder.maximum_network_interfaces = Some(deser.read_integer(member)?);
  223    223   
                }
  224    224   
                Some(3) => {
  225    225   
                    builder.baseline_bandwidth_in_gbps = Some(deser.read_double(member)?);
  226    226   
                }
  227    227   
                Some(4) => {
  228    228   
                    builder.peak_bandwidth_in_gbps = Some(deser.read_double(member)?);
  229    229   
                }
  230    230   
                Some(5) => {
  231    231   
                    builder.default_ena_queue_count_per_interface = Some(deser.read_integer(member)?);
  232    232   
                }
  233    233   
                Some(6) => {
  234    234   
                    builder.maximum_ena_queue_count = Some(deser.read_integer(member)?);
  235    235   
                }
  236    236   
                Some(7) => {
  237    237   
                    builder.maximum_ena_queue_count_per_interface = Some(deser.read_integer(member)?);
  238    238   
                }
  239    239   
                _ => {}
  240    240   
            }
  241    241   
            Ok(())
  242    242   
        })?;
  243    243   
        Ok(builder.build())
  244    244   
    }
  245    245   
}
         246  +
impl NetworkCardInfo {
         247  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         248  +
    pub fn deserialize_with_response(
         249  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         250  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         251  +
        _status: u16,
         252  +
        _body: &[u8],
         253  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         254  +
        Self::deserialize(deserializer)
         255  +
    }
         256  +
}
  246    257   
impl NetworkCardInfo {
  247    258   
    /// Creates a new builder-style object to manufacture [`NetworkCardInfo`](crate::types::NetworkCardInfo).
  248    259   
    pub fn builder() -> crate::types::builders::NetworkCardInfoBuilder {
  249    260   
        crate::types::builders::NetworkCardInfoBuilder::default()
  250    261   
    }
  251    262   
}
  252    263   
  253    264   
/// A builder for [`NetworkCardInfo`](crate::types::NetworkCardInfo).
  254    265   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  255    266   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_info.rs

@@ -79,79 +261,261 @@
   99     99   
    /// <p>Indicates whether changing the number of ENA queues is supported.</p>
  100    100   
    pub fn flexible_ena_queues_support(&self) -> ::std::option::Option<&crate::types::FlexibleEnaQueuesSupport> {
  101    101   
        self.flexible_ena_queues_support.as_ref()
  102    102   
    }
  103    103   
}
  104    104   
static NETWORKINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  105    105   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInfo", "com.amazonaws.ec2", "NetworkInfo");
  106    106   
static NETWORKINFO_MEMBER_NETWORK_PERFORMANCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInfo$NetworkPerformance", "com.amazonaws.ec2", "NetworkInfo"),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "network_performance",
         109  +
    "NetworkPerformance",
  110    110   
    0,
  111    111   
)
  112    112   
.with_xml_name("networkPerformance");
  113    113   
static NETWORKINFO_MEMBER_MAXIMUM_NETWORK_INTERFACES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static(
  115    115   
        "com.amazonaws.ec2#NetworkInfo$MaximumNetworkInterfaces",
  116    116   
        "com.amazonaws.ec2",
  117    117   
        "NetworkInfo",
  118    118   
    ),
  119    119   
    ::aws_smithy_schema::ShapeType::Integer,
  120         -
    "maximum_network_interfaces",
         120  +
    "MaximumNetworkInterfaces",
  121    121   
    1,
  122    122   
)
  123    123   
.with_xml_name("maximumNetworkInterfaces");
  124    124   
static NETWORKINFO_MEMBER_MAXIMUM_NETWORK_CARDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInfo$MaximumNetworkCards", "com.amazonaws.ec2", "NetworkInfo"),
  126    126   
    ::aws_smithy_schema::ShapeType::Integer,
  127         -
    "maximum_network_cards",
         127  +
    "MaximumNetworkCards",
  128    128   
    2,
  129    129   
)
  130    130   
.with_xml_name("maximumNetworkCards");
  131    131   
static NETWORKINFO_MEMBER_DEFAULT_NETWORK_CARD_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  132    132   
    ::aws_smithy_schema::ShapeId::from_static(
  133    133   
        "com.amazonaws.ec2#NetworkInfo$DefaultNetworkCardIndex",
  134    134   
        "com.amazonaws.ec2",
  135    135   
        "NetworkInfo",
  136    136   
    ),
  137    137   
    ::aws_smithy_schema::ShapeType::Integer,
  138         -
    "default_network_card_index",
         138  +
    "DefaultNetworkCardIndex",
  139    139   
    3,
  140    140   
)
  141    141   
.with_xml_name("defaultNetworkCardIndex");
  142    142   
static NETWORKINFO_MEMBER_NETWORK_CARDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  143    143   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInfo$NetworkCards", "com.amazonaws.ec2", "NetworkInfo"),
  144    144   
    ::aws_smithy_schema::ShapeType::List,
  145         -
    "network_cards",
         145  +
    "NetworkCards",
  146    146   
    4,
  147    147   
)
  148    148   
.with_xml_name("networkCards");
  149    149   
static NETWORKINFO_MEMBER_IPV4_ADDRESSES_PER_INTERFACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static(
  151    151   
        "com.amazonaws.ec2#NetworkInfo$Ipv4AddressesPerInterface",
  152    152   
        "com.amazonaws.ec2",
  153    153   
        "NetworkInfo",
  154    154   
    ),
  155    155   
    ::aws_smithy_schema::ShapeType::Integer,
  156         -
    "ipv4_addresses_per_interface",
         156  +
    "Ipv4AddressesPerInterface",
  157    157   
    5,
  158    158   
)
  159    159   
.with_xml_name("ipv4AddressesPerInterface");
  160    160   
static NETWORKINFO_MEMBER_IPV6_ADDRESSES_PER_INTERFACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  161    161   
    ::aws_smithy_schema::ShapeId::from_static(
  162    162   
        "com.amazonaws.ec2#NetworkInfo$Ipv6AddressesPerInterface",
  163    163   
        "com.amazonaws.ec2",
  164    164   
        "NetworkInfo",
  165    165   
    ),
  166    166   
    ::aws_smithy_schema::ShapeType::Integer,
  167         -
    "ipv6_addresses_per_interface",
         167  +
    "Ipv6AddressesPerInterface",
  168    168   
    6,
  169    169   
)
  170    170   
.with_xml_name("ipv6AddressesPerInterface");
  171    171   
static NETWORKINFO_MEMBER_IPV6_SUPPORTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  172    172   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInfo$Ipv6Supported", "com.amazonaws.ec2", "NetworkInfo"),
  173    173   
    ::aws_smithy_schema::ShapeType::Boolean,
  174         -
    "ipv6_supported",
         174  +
    "Ipv6Supported",
  175    175   
    7,
  176    176   
)
  177    177   
.with_xml_name("ipv6Supported");
  178    178   
static NETWORKINFO_MEMBER_ENA_SUPPORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInfo$EnaSupport", "com.amazonaws.ec2", "NetworkInfo"),
  180    180   
    ::aws_smithy_schema::ShapeType::String,
  181         -
    "ena_support",
         181  +
    "EnaSupport",
  182    182   
    8,
  183    183   
)
  184    184   
.with_xml_name("enaSupport");
  185    185   
static NETWORKINFO_MEMBER_EFA_SUPPORTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  186    186   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInfo$EfaSupported", "com.amazonaws.ec2", "NetworkInfo"),
  187    187   
    ::aws_smithy_schema::ShapeType::Boolean,
  188         -
    "efa_supported",
         188  +
    "EfaSupported",
  189    189   
    9,
  190    190   
)
  191    191   
.with_xml_name("efaSupported");
  192    192   
static NETWORKINFO_MEMBER_EFA_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  193    193   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInfo$EfaInfo", "com.amazonaws.ec2", "NetworkInfo"),
  194    194   
    ::aws_smithy_schema::ShapeType::Structure,
  195         -
    "efa_info",
         195  +
    "EfaInfo",
  196    196   
    10,
  197    197   
)
  198    198   
.with_xml_name("efaInfo");
  199    199   
static NETWORKINFO_MEMBER_ENCRYPTION_IN_TRANSIT_SUPPORTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  200    200   
    ::aws_smithy_schema::ShapeId::from_static(
  201    201   
        "com.amazonaws.ec2#NetworkInfo$EncryptionInTransitSupported",
  202    202   
        "com.amazonaws.ec2",
  203    203   
        "NetworkInfo",
  204    204   
    ),
  205    205   
    ::aws_smithy_schema::ShapeType::Boolean,
  206         -
    "encryption_in_transit_supported",
         206  +
    "EncryptionInTransitSupported",
  207    207   
    11,
  208    208   
)
  209    209   
.with_xml_name("encryptionInTransitSupported");
  210    210   
static NETWORKINFO_MEMBER_ENA_SRD_SUPPORTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  211    211   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInfo$EnaSrdSupported", "com.amazonaws.ec2", "NetworkInfo"),
  212    212   
    ::aws_smithy_schema::ShapeType::Boolean,
  213         -
    "ena_srd_supported",
         213  +
    "EnaSrdSupported",
  214    214   
    12,
  215    215   
)
  216    216   
.with_xml_name("enaSrdSupported");
  217    217   
static NETWORKINFO_MEMBER_BANDWIDTH_WEIGHTINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  218    218   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInfo$BandwidthWeightings", "com.amazonaws.ec2", "NetworkInfo"),
  219    219   
    ::aws_smithy_schema::ShapeType::List,
  220         -
    "bandwidth_weightings",
         220  +
    "BandwidthWeightings",
  221    221   
    13,
  222    222   
)
  223    223   
.with_xml_name("bandwidthWeightings");
  224    224   
static NETWORKINFO_MEMBER_FLEXIBLE_ENA_QUEUES_SUPPORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  225    225   
    ::aws_smithy_schema::ShapeId::from_static(
  226    226   
        "com.amazonaws.ec2#NetworkInfo$FlexibleEnaQueuesSupport",
  227    227   
        "com.amazonaws.ec2",
  228    228   
        "NetworkInfo",
  229    229   
    ),
  230    230   
    ::aws_smithy_schema::ShapeType::String,
  231         -
    "flexible_ena_queues_support",
         231  +
    "FlexibleEnaQueuesSupport",
  232    232   
    14,
  233    233   
)
  234    234   
.with_xml_name("flexibleEnaQueuesSupport");
  235    235   
static NETWORKINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  236    236   
    NETWORKINFO_SCHEMA_ID,
  237    237   
    ::aws_smithy_schema::ShapeType::Structure,
  238    238   
    &[
  239    239   
        &NETWORKINFO_MEMBER_NETWORK_PERFORMANCE,
  240    240   
        &NETWORKINFO_MEMBER_MAXIMUM_NETWORK_INTERFACES,
  241    241   
        &NETWORKINFO_MEMBER_MAXIMUM_NETWORK_CARDS,
@@ -302,302 +447,452 @@
  322    322   
            )?;
  323    323   
        }
  324    324   
        if let Some(ref val) = self.flexible_ena_queues_support {
  325    325   
            ser.write_string(&NETWORKINFO_MEMBER_FLEXIBLE_ENA_QUEUES_SUPPORT, val.as_str())?;
  326    326   
        }
  327    327   
        Ok(())
  328    328   
    }
  329    329   
}
  330    330   
impl NetworkInfo {
  331    331   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  332         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  333         -
        deserializer: &mut D,
         332  +
    pub fn deserialize(
         333  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  334    334   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  335    335   
        #[allow(unused_variables, unused_mut)]
  336    336   
        let mut builder = Self::builder();
  337    337   
        #[allow(
  338    338   
            unused_variables,
  339    339   
            unreachable_code,
  340    340   
            clippy::single_match,
  341    341   
            clippy::match_single_binding,
  342    342   
            clippy::diverging_sub_expression
  343    343   
        )]
  344         -
        deserializer.read_struct(&NETWORKINFO_SCHEMA, (), |_, member, deser| {
         344  +
        deserializer.read_struct(&NETWORKINFO_SCHEMA, &mut |member, deser| {
  345    345   
            match member.member_index() {
  346    346   
                Some(0) => {
  347    347   
                    builder.network_performance = Some(deser.read_string(member)?);
  348    348   
                }
  349    349   
                Some(1) => {
  350    350   
                    builder.maximum_network_interfaces = Some(deser.read_integer(member)?);
  351    351   
                }
  352    352   
                Some(2) => {
  353    353   
                    builder.maximum_network_cards = Some(deser.read_integer(member)?);
  354    354   
                }
  355    355   
                Some(3) => {
  356    356   
                    builder.default_network_card_index = Some(deser.read_integer(member)?);
  357    357   
                }
  358    358   
                Some(4) => {
  359    359   
                    builder.network_cards = Some({
  360         -
                        let container = if let Some(cap) = deser.container_size() {
  361         -
                            Vec::with_capacity(cap)
  362         -
                        } else {
  363         -
                            Vec::new()
  364         -
                        };
  365         -
                        deser.read_list(member, container, |mut list, deser| {
  366         -
                            list.push(crate::types::NetworkCardInfo::deserialize(deser)?);
  367         -
                            Ok(list)
  368         -
                        })?
         360  +
                        let mut container = Vec::new();
         361  +
                        deser.read_list(member, &mut |deser| {
         362  +
                            container.push(crate::types::NetworkCardInfo::deserialize(deser)?);
         363  +
                            Ok(())
         364  +
                        })?;
         365  +
                        container
  369    366   
                    });
  370    367   
                }
  371    368   
                Some(5) => {
  372    369   
                    builder.ipv4_addresses_per_interface = Some(deser.read_integer(member)?);
  373    370   
                }
  374    371   
                Some(6) => {
  375    372   
                    builder.ipv6_addresses_per_interface = Some(deser.read_integer(member)?);
  376    373   
                }
  377    374   
                Some(7) => {
  378    375   
                    builder.ipv6_supported = Some(deser.read_boolean(member)?);
  379    376   
                }
  380    377   
                Some(8) => {
  381    378   
                    builder.ena_support = Some(crate::types::EnaSupport::from(deser.read_string(member)?.as_str()));
  382    379   
                }
  383    380   
                Some(9) => {
  384    381   
                    builder.efa_supported = Some(deser.read_boolean(member)?);
  385    382   
                }
  386    383   
                Some(10) => {
  387    384   
                    builder.efa_info = Some(crate::types::EfaInfo::deserialize(deser)?);
  388    385   
                }
  389    386   
                Some(11) => {
  390    387   
                    builder.encryption_in_transit_supported = Some(deser.read_boolean(member)?);
  391    388   
                }
  392    389   
                Some(12) => {
  393    390   
                    builder.ena_srd_supported = Some(deser.read_boolean(member)?);
  394    391   
                }
  395    392   
                Some(13) => {
  396    393   
                    builder.bandwidth_weightings = Some({
  397         -
                        let container = if let Some(cap) = deser.container_size() {
  398         -
                            Vec::with_capacity(cap)
  399         -
                        } else {
  400         -
                            Vec::new()
  401         -
                        };
  402         -
                        deser.read_list(member, container, |mut list, deser| {
  403         -
                            list.push(crate::types::BandwidthWeightingType::from(deser.read_string(member)?.as_str()));
  404         -
                            Ok(list)
  405         -
                        })?
         394  +
                        let mut container = Vec::new();
         395  +
                        deser.read_list(member, &mut |deser| {
         396  +
                            container.push(crate::types::BandwidthWeightingType::from(deser.read_string(member)?.as_str()));
         397  +
                            Ok(())
         398  +
                        })?;
         399  +
                        container
  406    400   
                    });
  407    401   
                }
  408    402   
                Some(14) => {
  409    403   
                    builder.flexible_ena_queues_support = Some(crate::types::FlexibleEnaQueuesSupport::from(deser.read_string(member)?.as_str()));
  410    404   
                }
  411    405   
                _ => {}
  412    406   
            }
  413    407   
            Ok(())
  414    408   
        })?;
  415    409   
        Ok(builder.build())
  416    410   
    }
  417    411   
}
         412  +
impl NetworkInfo {
         413  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         414  +
    pub fn deserialize_with_response(
         415  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         416  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         417  +
        _status: u16,
         418  +
        _body: &[u8],
         419  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         420  +
        Self::deserialize(deserializer)
         421  +
    }
         422  +
}
  418    423   
impl NetworkInfo {
  419    424   
    /// Creates a new builder-style object to manufacture [`NetworkInfo`](crate::types::NetworkInfo).
  420    425   
    pub fn builder() -> crate::types::builders::NetworkInfoBuilder {
  421    426   
        crate::types::builders::NetworkInfoBuilder::default()
  422    427   
    }
  423    428   
}
  424    429   
  425    430   
/// A builder for [`NetworkInfo`](crate::types::NetworkInfo).
  426    431   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  427    432   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_insights_access_scope.rs

@@ -24,24 +226,234 @@
   44     44   
    "com.amazonaws.ec2",
   45     45   
    "NetworkInsightsAccessScope",
   46     46   
);
   47     47   
static NETWORKINSIGHTSACCESSSCOPE_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   48     48   
    ::aws_smithy_schema::ShapeId::from_static(
   49     49   
        "com.amazonaws.ec2#NetworkInsightsAccessScope$NetworkInsightsAccessScopeId",
   50     50   
        "com.amazonaws.ec2",
   51     51   
        "NetworkInsightsAccessScope",
   52     52   
    ),
   53     53   
    ::aws_smithy_schema::ShapeType::String,
   54         -
    "network_insights_access_scope_id",
          54  +
    "NetworkInsightsAccessScopeId",
   55     55   
    0,
   56     56   
)
   57     57   
.with_xml_name("networkInsightsAccessScopeId");
   58     58   
static NETWORKINSIGHTSACCESSSCOPE_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static(
   60     60   
        "com.amazonaws.ec2#NetworkInsightsAccessScope$NetworkInsightsAccessScopeArn",
   61     61   
        "com.amazonaws.ec2",
   62     62   
        "NetworkInsightsAccessScope",
   63     63   
    ),
   64     64   
    ::aws_smithy_schema::ShapeType::String,
   65         -
    "network_insights_access_scope_arn",
          65  +
    "NetworkInsightsAccessScopeArn",
   66     66   
    1,
   67     67   
)
   68     68   
.with_xml_name("networkInsightsAccessScopeArn");
   69     69   
static NETWORKINSIGHTSACCESSSCOPE_MEMBER_CREATED_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.ec2#NetworkInsightsAccessScope$CreatedDate",
   72     72   
        "com.amazonaws.ec2",
   73     73   
        "NetworkInsightsAccessScope",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::Timestamp,
   76         -
    "created_date",
          76  +
    "CreatedDate",
   77     77   
    2,
   78     78   
)
   79     79   
.with_xml_name("createdDate");
   80     80   
static NETWORKINSIGHTSACCESSSCOPE_MEMBER_UPDATED_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static(
   82     82   
        "com.amazonaws.ec2#NetworkInsightsAccessScope$UpdatedDate",
   83     83   
        "com.amazonaws.ec2",
   84     84   
        "NetworkInsightsAccessScope",
   85     85   
    ),
   86     86   
    ::aws_smithy_schema::ShapeType::Timestamp,
   87         -
    "updated_date",
          87  +
    "UpdatedDate",
   88     88   
    3,
   89     89   
)
   90     90   
.with_xml_name("updatedDate");
   91     91   
static NETWORKINSIGHTSACCESSSCOPE_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.ec2#NetworkInsightsAccessScope$Tags",
   94     94   
        "com.amazonaws.ec2",
   95     95   
        "NetworkInsightsAccessScope",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::List,
   98         -
    "tags",
          98  +
    "Tags",
   99     99   
    4,
  100    100   
)
  101    101   
.with_xml_name("tagSet");
  102    102   
static NETWORKINSIGHTSACCESSSCOPE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  103    103   
    NETWORKINSIGHTSACCESSSCOPE_SCHEMA_ID,
  104    104   
    ::aws_smithy_schema::ShapeType::Structure,
  105    105   
    &[
  106    106   
        &NETWORKINSIGHTSACCESSSCOPE_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_ID,
  107    107   
        &NETWORKINSIGHTSACCESSSCOPE_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_ARN,
  108    108   
        &NETWORKINSIGHTSACCESSSCOPE_MEMBER_CREATED_DATE,
  109    109   
        &NETWORKINSIGHTSACCESSSCOPE_MEMBER_UPDATED_DATE,
  110    110   
        &NETWORKINSIGHTSACCESSSCOPE_MEMBER_TAGS,
  111    111   
    ],
  112    112   
);
  113    113   
impl NetworkInsightsAccessScope {
  114    114   
    /// The schema for this shape.
  115    115   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NETWORKINSIGHTSACCESSSCOPE_SCHEMA;
  116    116   
}
  117    117   
impl ::aws_smithy_schema::serde::SerializableStruct for NetworkInsightsAccessScope {
  118    118   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  119    119   
    fn serialize_members(
  120    120   
        &self,
  121    121   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  122    122   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  123    123   
        if let Some(ref val) = self.network_insights_access_scope_id {
  124    124   
            ser.write_string(&NETWORKINSIGHTSACCESSSCOPE_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_ID, val)?;
  125    125   
        }
  126    126   
        if let Some(ref val) = self.network_insights_access_scope_arn {
  127    127   
            ser.write_string(&NETWORKINSIGHTSACCESSSCOPE_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_ARN, val)?;
  128    128   
        }
  129    129   
        if let Some(ref val) = self.created_date {
  130    130   
            ser.write_timestamp(&NETWORKINSIGHTSACCESSSCOPE_MEMBER_CREATED_DATE, val)?;
  131    131   
        }
  132    132   
        if let Some(ref val) = self.updated_date {
  133    133   
            ser.write_timestamp(&NETWORKINSIGHTSACCESSSCOPE_MEMBER_UPDATED_DATE, val)?;
  134    134   
        }
  135    135   
        if let Some(ref val) = self.tags {
  136    136   
            ser.write_list(
  137    137   
                &NETWORKINSIGHTSACCESSSCOPE_MEMBER_TAGS,
  138    138   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  139    139   
                    for item in val {
  140    140   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  141    141   
                    }
  142    142   
                    Ok(())
  143    143   
                },
  144    144   
            )?;
  145    145   
        }
  146    146   
        Ok(())
  147    147   
    }
  148    148   
}
  149    149   
impl NetworkInsightsAccessScope {
  150    150   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  151         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  152         -
        deserializer: &mut D,
         151  +
    pub fn deserialize(
         152  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  153    153   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  154    154   
        #[allow(unused_variables, unused_mut)]
  155    155   
        let mut builder = Self::builder();
  156    156   
        #[allow(
  157    157   
            unused_variables,
  158    158   
            unreachable_code,
  159    159   
            clippy::single_match,
  160    160   
            clippy::match_single_binding,
  161    161   
            clippy::diverging_sub_expression
  162    162   
        )]
  163         -
        deserializer.read_struct(&NETWORKINSIGHTSACCESSSCOPE_SCHEMA, (), |_, member, deser| {
         163  +
        deserializer.read_struct(&NETWORKINSIGHTSACCESSSCOPE_SCHEMA, &mut |member, deser| {
  164    164   
            match member.member_index() {
  165    165   
                Some(0) => {
  166    166   
                    builder.network_insights_access_scope_id = Some(deser.read_string(member)?);
  167    167   
                }
  168    168   
                Some(1) => {
  169    169   
                    builder.network_insights_access_scope_arn = Some(deser.read_string(member)?);
  170    170   
                }
  171    171   
                Some(2) => {
  172    172   
                    builder.created_date = Some(deser.read_timestamp(member)?);
  173    173   
                }
  174    174   
                Some(3) => {
  175    175   
                    builder.updated_date = Some(deser.read_timestamp(member)?);
  176    176   
                }
  177    177   
                Some(4) => {
  178    178   
                    builder.tags = Some({
  179         -
                        let container = if let Some(cap) = deser.container_size() {
  180         -
                            Vec::with_capacity(cap)
  181         -
                        } else {
  182         -
                            Vec::new()
  183         -
                        };
  184         -
                        deser.read_list(member, container, |mut list, deser| {
  185         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  186         -
                            Ok(list)
  187         -
                        })?
         179  +
                        let mut container = Vec::new();
         180  +
                        deser.read_list(member, &mut |deser| {
         181  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         182  +
                            Ok(())
         183  +
                        })?;
         184  +
                        container
  188    185   
                    });
  189    186   
                }
  190    187   
                _ => {}
  191    188   
            }
  192    189   
            Ok(())
  193    190   
        })?;
  194    191   
        Ok(builder.build())
  195    192   
    }
  196    193   
}
         194  +
impl NetworkInsightsAccessScope {
         195  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         196  +
    pub fn deserialize_with_response(
         197  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         198  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         199  +
        _status: u16,
         200  +
        _body: &[u8],
         201  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         202  +
        Self::deserialize(deserializer)
         203  +
    }
         204  +
}
  197    205   
impl NetworkInsightsAccessScope {
  198    206   
    /// Creates a new builder-style object to manufacture [`NetworkInsightsAccessScope`](crate::types::NetworkInsightsAccessScope).
  199    207   
    pub fn builder() -> crate::types::builders::NetworkInsightsAccessScopeBuilder {
  200    208   
        crate::types::builders::NetworkInsightsAccessScopeBuilder::default()
  201    209   
    }
  202    210   
}
  203    211   
  204    212   
/// A builder for [`NetworkInsightsAccessScope`](crate::types::NetworkInsightsAccessScope).
  205    213   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  206    214   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_insights_access_scope_analysis.rs

@@ -61,61 +233,233 @@
   81     81   
    "NetworkInsightsAccessScopeAnalysis",
   82     82   
);
   83     83   
static NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_ANALYSIS_ID: ::aws_smithy_schema::Schema =
   84     84   
    ::aws_smithy_schema::Schema::new_member(
   85     85   
        ::aws_smithy_schema::ShapeId::from_static(
   86     86   
            "com.amazonaws.ec2#NetworkInsightsAccessScopeAnalysis$NetworkInsightsAccessScopeAnalysisId",
   87     87   
            "com.amazonaws.ec2",
   88     88   
            "NetworkInsightsAccessScopeAnalysis",
   89     89   
        ),
   90     90   
        ::aws_smithy_schema::ShapeType::String,
   91         -
        "network_insights_access_scope_analysis_id",
          91  +
        "NetworkInsightsAccessScopeAnalysisId",
   92     92   
        0,
   93     93   
    )
   94     94   
    .with_xml_name("networkInsightsAccessScopeAnalysisId");
   95     95   
static NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_ANALYSIS_ARN: ::aws_smithy_schema::Schema =
   96     96   
    ::aws_smithy_schema::Schema::new_member(
   97     97   
        ::aws_smithy_schema::ShapeId::from_static(
   98     98   
            "com.amazonaws.ec2#NetworkInsightsAccessScopeAnalysis$NetworkInsightsAccessScopeAnalysisArn",
   99     99   
            "com.amazonaws.ec2",
  100    100   
            "NetworkInsightsAccessScopeAnalysis",
  101    101   
        ),
  102    102   
        ::aws_smithy_schema::ShapeType::String,
  103         -
        "network_insights_access_scope_analysis_arn",
         103  +
        "NetworkInsightsAccessScopeAnalysisArn",
  104    104   
        1,
  105    105   
    )
  106    106   
    .with_xml_name("networkInsightsAccessScopeAnalysisArn");
  107    107   
static NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_ID: ::aws_smithy_schema::Schema =
  108    108   
    ::aws_smithy_schema::Schema::new_member(
  109    109   
        ::aws_smithy_schema::ShapeId::from_static(
  110    110   
            "com.amazonaws.ec2#NetworkInsightsAccessScopeAnalysis$NetworkInsightsAccessScopeId",
  111    111   
            "com.amazonaws.ec2",
  112    112   
            "NetworkInsightsAccessScopeAnalysis",
  113    113   
        ),
  114    114   
        ::aws_smithy_schema::ShapeType::String,
  115         -
        "network_insights_access_scope_id",
         115  +
        "NetworkInsightsAccessScopeId",
  116    116   
        2,
  117    117   
    )
  118    118   
    .with_xml_name("networkInsightsAccessScopeId");
  119    119   
static NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.ec2#NetworkInsightsAccessScopeAnalysis$Status",
  122    122   
        "com.amazonaws.ec2",
  123    123   
        "NetworkInsightsAccessScopeAnalysis",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::String,
  126         -
    "status",
         126  +
    "Status",
  127    127   
    3,
  128    128   
)
  129    129   
.with_xml_name("status");
  130    130   
static NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static(
  132    132   
        "com.amazonaws.ec2#NetworkInsightsAccessScopeAnalysis$StatusMessage",
  133    133   
        "com.amazonaws.ec2",
  134    134   
        "NetworkInsightsAccessScopeAnalysis",
  135    135   
    ),
  136    136   
    ::aws_smithy_schema::ShapeType::String,
  137         -
    "status_message",
         137  +
    "StatusMessage",
  138    138   
    4,
  139    139   
)
  140    140   
.with_xml_name("statusMessage");
  141    141   
static NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_WARNING_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  142    142   
    ::aws_smithy_schema::ShapeId::from_static(
  143    143   
        "com.amazonaws.ec2#NetworkInsightsAccessScopeAnalysis$WarningMessage",
  144    144   
        "com.amazonaws.ec2",
  145    145   
        "NetworkInsightsAccessScopeAnalysis",
  146    146   
    ),
  147    147   
    ::aws_smithy_schema::ShapeType::String,
  148         -
    "warning_message",
         148  +
    "WarningMessage",
  149    149   
    5,
  150    150   
)
  151    151   
.with_xml_name("warningMessage");
  152    152   
static NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_START_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  153    153   
    ::aws_smithy_schema::ShapeId::from_static(
  154    154   
        "com.amazonaws.ec2#NetworkInsightsAccessScopeAnalysis$StartDate",
  155    155   
        "com.amazonaws.ec2",
  156    156   
        "NetworkInsightsAccessScopeAnalysis",
  157    157   
    ),
  158    158   
    ::aws_smithy_schema::ShapeType::Timestamp,
  159         -
    "start_date",
         159  +
    "StartDate",
  160    160   
    6,
  161    161   
)
  162    162   
.with_xml_name("startDate");
  163    163   
static NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  164    164   
    ::aws_smithy_schema::ShapeId::from_static(
  165    165   
        "com.amazonaws.ec2#NetworkInsightsAccessScopeAnalysis$EndDate",
  166    166   
        "com.amazonaws.ec2",
  167    167   
        "NetworkInsightsAccessScopeAnalysis",
  168    168   
    ),
  169    169   
    ::aws_smithy_schema::ShapeType::Timestamp,
  170         -
    "end_date",
         170  +
    "EndDate",
  171    171   
    7,
  172    172   
)
  173    173   
.with_xml_name("endDate");
  174    174   
static NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_FINDINGS_FOUND: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  175    175   
    ::aws_smithy_schema::ShapeId::from_static(
  176    176   
        "com.amazonaws.ec2#NetworkInsightsAccessScopeAnalysis$FindingsFound",
  177    177   
        "com.amazonaws.ec2",
  178    178   
        "NetworkInsightsAccessScopeAnalysis",
  179    179   
    ),
  180    180   
    ::aws_smithy_schema::ShapeType::String,
  181         -
    "findings_found",
         181  +
    "FindingsFound",
  182    182   
    8,
  183    183   
)
  184    184   
.with_xml_name("findingsFound");
  185    185   
static NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_ANALYZED_ENI_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  186    186   
    ::aws_smithy_schema::ShapeId::from_static(
  187    187   
        "com.amazonaws.ec2#NetworkInsightsAccessScopeAnalysis$AnalyzedEniCount",
  188    188   
        "com.amazonaws.ec2",
  189    189   
        "NetworkInsightsAccessScopeAnalysis",
  190    190   
    ),
  191    191   
    ::aws_smithy_schema::ShapeType::Integer,
  192         -
    "analyzed_eni_count",
         192  +
    "AnalyzedEniCount",
  193    193   
    9,
  194    194   
)
  195    195   
.with_xml_name("analyzedEniCount");
  196    196   
static NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  197    197   
    ::aws_smithy_schema::ShapeId::from_static(
  198    198   
        "com.amazonaws.ec2#NetworkInsightsAccessScopeAnalysis$Tags",
  199    199   
        "com.amazonaws.ec2",
  200    200   
        "NetworkInsightsAccessScopeAnalysis",
  201    201   
    ),
  202    202   
    ::aws_smithy_schema::ShapeType::List,
  203         -
    "tags",
         203  +
    "Tags",
  204    204   
    10,
  205    205   
)
  206    206   
.with_xml_name("tagSet");
  207    207   
static NETWORKINSIGHTSACCESSSCOPEANALYSIS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  208    208   
    NETWORKINSIGHTSACCESSSCOPEANALYSIS_SCHEMA_ID,
  209    209   
    ::aws_smithy_schema::ShapeType::Structure,
  210    210   
    &[
  211    211   
        &NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_ANALYSIS_ID,
  212    212   
        &NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_ANALYSIS_ARN,
  213    213   
        &NETWORKINSIGHTSACCESSSCOPEANALYSIS_MEMBER_NETWORK_INSIGHTS_ACCESS_SCOPE_ID,
@@ -250,250 +373,381 @@
  270    270   
                    }
  271    271   
                    Ok(())
  272    272   
                },
  273    273   
            )?;
  274    274   
        }
  275    275   
        Ok(())
  276    276   
    }
  277    277   
}
  278    278   
impl NetworkInsightsAccessScopeAnalysis {
  279    279   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  280         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  281         -
        deserializer: &mut D,
         280  +
    pub fn deserialize(
         281  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  282    282   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  283    283   
        #[allow(unused_variables, unused_mut)]
  284    284   
        let mut builder = Self::builder();
  285    285   
        #[allow(
  286    286   
            unused_variables,
  287    287   
            unreachable_code,
  288    288   
            clippy::single_match,
  289    289   
            clippy::match_single_binding,
  290    290   
            clippy::diverging_sub_expression
  291    291   
        )]
  292         -
        deserializer.read_struct(&NETWORKINSIGHTSACCESSSCOPEANALYSIS_SCHEMA, (), |_, member, deser| {
         292  +
        deserializer.read_struct(&NETWORKINSIGHTSACCESSSCOPEANALYSIS_SCHEMA, &mut |member, deser| {
  293    293   
            match member.member_index() {
  294    294   
                Some(0) => {
  295    295   
                    builder.network_insights_access_scope_analysis_id = Some(deser.read_string(member)?);
  296    296   
                }
  297    297   
                Some(1) => {
  298    298   
                    builder.network_insights_access_scope_analysis_arn = Some(deser.read_string(member)?);
  299    299   
                }
  300    300   
                Some(2) => {
  301    301   
                    builder.network_insights_access_scope_id = Some(deser.read_string(member)?);
  302    302   
                }
  303    303   
                Some(3) => {
  304    304   
                    builder.status = Some(crate::types::AnalysisStatus::from(deser.read_string(member)?.as_str()));
  305    305   
                }
  306    306   
                Some(4) => {
  307    307   
                    builder.status_message = Some(deser.read_string(member)?);
  308    308   
                }
  309    309   
                Some(5) => {
  310    310   
                    builder.warning_message = Some(deser.read_string(member)?);
  311    311   
                }
  312    312   
                Some(6) => {
  313    313   
                    builder.start_date = Some(deser.read_timestamp(member)?);
  314    314   
                }
  315    315   
                Some(7) => {
  316    316   
                    builder.end_date = Some(deser.read_timestamp(member)?);
  317    317   
                }
  318    318   
                Some(8) => {
  319    319   
                    builder.findings_found = Some(crate::types::FindingsFound::from(deser.read_string(member)?.as_str()));
  320    320   
                }
  321    321   
                Some(9) => {
  322    322   
                    builder.analyzed_eni_count = Some(deser.read_integer(member)?);
  323    323   
                }
  324    324   
                Some(10) => {
  325    325   
                    builder.tags = Some({
  326         -
                        let container = if let Some(cap) = deser.container_size() {
  327         -
                            Vec::with_capacity(cap)
  328         -
                        } else {
  329         -
                            Vec::new()
  330         -
                        };
  331         -
                        deser.read_list(member, container, |mut list, deser| {
  332         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  333         -
                            Ok(list)
  334         -
                        })?
         326  +
                        let mut container = Vec::new();
         327  +
                        deser.read_list(member, &mut |deser| {
         328  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         329  +
                            Ok(())
         330  +
                        })?;
         331  +
                        container
  335    332   
                    });
  336    333   
                }
  337    334   
                _ => {}
  338    335   
            }
  339    336   
            Ok(())
  340    337   
        })?;
  341    338   
        Ok(builder.build())
  342    339   
    }
  343    340   
}
         341  +
impl NetworkInsightsAccessScopeAnalysis {
         342  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         343  +
    pub fn deserialize_with_response(
         344  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         345  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         346  +
        _status: u16,
         347  +
        _body: &[u8],
         348  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         349  +
        Self::deserialize(deserializer)
         350  +
    }
         351  +
}
  344    352   
impl NetworkInsightsAccessScopeAnalysis {
  345    353   
    /// Creates a new builder-style object to manufacture [`NetworkInsightsAccessScopeAnalysis`](crate::types::NetworkInsightsAccessScopeAnalysis).
  346    354   
    pub fn builder() -> crate::types::builders::NetworkInsightsAccessScopeAnalysisBuilder {
  347    355   
        crate::types::builders::NetworkInsightsAccessScopeAnalysisBuilder::default()
  348    356   
    }
  349    357   
}
  350    358   
  351    359   
/// A builder for [`NetworkInsightsAccessScopeAnalysis`](crate::types::NetworkInsightsAccessScopeAnalysis).
  352    360   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  353    361   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_insights_access_scope_content.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_insights_analysis.rs

@@ -112,112 +348,348 @@
  132    132   
    "com.amazonaws.ec2",
  133    133   
    "NetworkInsightsAnalysis",
  134    134   
);
  135    135   
static NETWORKINSIGHTSANALYSIS_MEMBER_NETWORK_INSIGHTS_ANALYSIS_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static(
  137    137   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$NetworkInsightsAnalysisId",
  138    138   
        "com.amazonaws.ec2",
  139    139   
        "NetworkInsightsAnalysis",
  140    140   
    ),
  141    141   
    ::aws_smithy_schema::ShapeType::String,
  142         -
    "network_insights_analysis_id",
         142  +
    "NetworkInsightsAnalysisId",
  143    143   
    0,
  144    144   
)
  145    145   
.with_xml_name("networkInsightsAnalysisId");
  146    146   
static NETWORKINSIGHTSANALYSIS_MEMBER_NETWORK_INSIGHTS_ANALYSIS_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  147    147   
    ::aws_smithy_schema::ShapeId::from_static(
  148    148   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$NetworkInsightsAnalysisArn",
  149    149   
        "com.amazonaws.ec2",
  150    150   
        "NetworkInsightsAnalysis",
  151    151   
    ),
  152    152   
    ::aws_smithy_schema::ShapeType::String,
  153         -
    "network_insights_analysis_arn",
         153  +
    "NetworkInsightsAnalysisArn",
  154    154   
    1,
  155    155   
)
  156    156   
.with_xml_name("networkInsightsAnalysisArn");
  157    157   
static NETWORKINSIGHTSANALYSIS_MEMBER_NETWORK_INSIGHTS_PATH_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  158    158   
    ::aws_smithy_schema::ShapeId::from_static(
  159    159   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$NetworkInsightsPathId",
  160    160   
        "com.amazonaws.ec2",
  161    161   
        "NetworkInsightsAnalysis",
  162    162   
    ),
  163    163   
    ::aws_smithy_schema::ShapeType::String,
  164         -
    "network_insights_path_id",
         164  +
    "NetworkInsightsPathId",
  165    165   
    2,
  166    166   
)
  167    167   
.with_xml_name("networkInsightsPathId");
  168    168   
static NETWORKINSIGHTSANALYSIS_MEMBER_ADDITIONAL_ACCOUNTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  169    169   
    ::aws_smithy_schema::ShapeId::from_static(
  170    170   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$AdditionalAccounts",
  171    171   
        "com.amazonaws.ec2",
  172    172   
        "NetworkInsightsAnalysis",
  173    173   
    ),
  174    174   
    ::aws_smithy_schema::ShapeType::List,
  175         -
    "additional_accounts",
         175  +
    "AdditionalAccounts",
  176    176   
    3,
  177    177   
)
  178    178   
.with_xml_name("additionalAccountSet");
  179    179   
static NETWORKINSIGHTSANALYSIS_MEMBER_FILTER_IN_ARNS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  180    180   
    ::aws_smithy_schema::ShapeId::from_static(
  181    181   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$FilterInArns",
  182    182   
        "com.amazonaws.ec2",
  183    183   
        "NetworkInsightsAnalysis",
  184    184   
    ),
  185    185   
    ::aws_smithy_schema::ShapeType::List,
  186         -
    "filter_in_arns",
         186  +
    "FilterInArns",
  187    187   
    4,
  188    188   
)
  189    189   
.with_xml_name("filterInArnSet");
  190    190   
static NETWORKINSIGHTSANALYSIS_MEMBER_FILTER_OUT_ARNS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  191    191   
    ::aws_smithy_schema::ShapeId::from_static(
  192    192   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$FilterOutArns",
  193    193   
        "com.amazonaws.ec2",
  194    194   
        "NetworkInsightsAnalysis",
  195    195   
    ),
  196    196   
    ::aws_smithy_schema::ShapeType::List,
  197         -
    "filter_out_arns",
         197  +
    "FilterOutArns",
  198    198   
    5,
  199    199   
)
  200    200   
.with_xml_name("filterOutArnSet");
  201    201   
static NETWORKINSIGHTSANALYSIS_MEMBER_START_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  202    202   
    ::aws_smithy_schema::ShapeId::from_static(
  203    203   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$StartDate",
  204    204   
        "com.amazonaws.ec2",
  205    205   
        "NetworkInsightsAnalysis",
  206    206   
    ),
  207    207   
    ::aws_smithy_schema::ShapeType::Timestamp,
  208         -
    "start_date",
         208  +
    "StartDate",
  209    209   
    6,
  210    210   
)
  211    211   
.with_xml_name("startDate");
  212    212   
static NETWORKINSIGHTSANALYSIS_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  213    213   
    ::aws_smithy_schema::ShapeId::from_static(
  214    214   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$Status",
  215    215   
        "com.amazonaws.ec2",
  216    216   
        "NetworkInsightsAnalysis",
  217    217   
    ),
  218    218   
    ::aws_smithy_schema::ShapeType::String,
  219         -
    "status",
         219  +
    "Status",
  220    220   
    7,
  221    221   
)
  222    222   
.with_xml_name("status");
  223    223   
static NETWORKINSIGHTSANALYSIS_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  224    224   
    ::aws_smithy_schema::ShapeId::from_static(
  225    225   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$StatusMessage",
  226    226   
        "com.amazonaws.ec2",
  227    227   
        "NetworkInsightsAnalysis",
  228    228   
    ),
  229    229   
    ::aws_smithy_schema::ShapeType::String,
  230         -
    "status_message",
         230  +
    "StatusMessage",
  231    231   
    8,
  232    232   
)
  233    233   
.with_xml_name("statusMessage");
  234    234   
static NETWORKINSIGHTSANALYSIS_MEMBER_WARNING_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  235    235   
    ::aws_smithy_schema::ShapeId::from_static(
  236    236   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$WarningMessage",
  237    237   
        "com.amazonaws.ec2",
  238    238   
        "NetworkInsightsAnalysis",
  239    239   
    ),
  240    240   
    ::aws_smithy_schema::ShapeType::String,
  241         -
    "warning_message",
         241  +
    "WarningMessage",
  242    242   
    9,
  243    243   
)
  244    244   
.with_xml_name("warningMessage");
  245    245   
static NETWORKINSIGHTSANALYSIS_MEMBER_NETWORK_PATH_FOUND: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  246    246   
    ::aws_smithy_schema::ShapeId::from_static(
  247    247   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$NetworkPathFound",
  248    248   
        "com.amazonaws.ec2",
  249    249   
        "NetworkInsightsAnalysis",
  250    250   
    ),
  251    251   
    ::aws_smithy_schema::ShapeType::Boolean,
  252         -
    "network_path_found",
         252  +
    "NetworkPathFound",
  253    253   
    10,
  254    254   
)
  255    255   
.with_xml_name("networkPathFound");
  256    256   
static NETWORKINSIGHTSANALYSIS_MEMBER_FORWARD_PATH_COMPONENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  257    257   
    ::aws_smithy_schema::ShapeId::from_static(
  258    258   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$ForwardPathComponents",
  259    259   
        "com.amazonaws.ec2",
  260    260   
        "NetworkInsightsAnalysis",
  261    261   
    ),
  262    262   
    ::aws_smithy_schema::ShapeType::List,
  263         -
    "forward_path_components",
         263  +
    "ForwardPathComponents",
  264    264   
    11,
  265    265   
)
  266    266   
.with_xml_name("forwardPathComponentSet");
  267    267   
static NETWORKINSIGHTSANALYSIS_MEMBER_RETURN_PATH_COMPONENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  268    268   
    ::aws_smithy_schema::ShapeId::from_static(
  269    269   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$ReturnPathComponents",
  270    270   
        "com.amazonaws.ec2",
  271    271   
        "NetworkInsightsAnalysis",
  272    272   
    ),
  273    273   
    ::aws_smithy_schema::ShapeType::List,
  274         -
    "return_path_components",
         274  +
    "ReturnPathComponents",
  275    275   
    12,
  276    276   
)
  277    277   
.with_xml_name("returnPathComponentSet");
  278    278   
static NETWORKINSIGHTSANALYSIS_MEMBER_EXPLANATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  279    279   
    ::aws_smithy_schema::ShapeId::from_static(
  280    280   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$Explanations",
  281    281   
        "com.amazonaws.ec2",
  282    282   
        "NetworkInsightsAnalysis",
  283    283   
    ),
  284    284   
    ::aws_smithy_schema::ShapeType::List,
  285         -
    "explanations",
         285  +
    "Explanations",
  286    286   
    13,
  287    287   
)
  288    288   
.with_xml_name("explanationSet");
  289    289   
static NETWORKINSIGHTSANALYSIS_MEMBER_ALTERNATE_PATH_HINTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  290    290   
    ::aws_smithy_schema::ShapeId::from_static(
  291    291   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$AlternatePathHints",
  292    292   
        "com.amazonaws.ec2",
  293    293   
        "NetworkInsightsAnalysis",
  294    294   
    ),
  295    295   
    ::aws_smithy_schema::ShapeType::List,
  296         -
    "alternate_path_hints",
         296  +
    "AlternatePathHints",
  297    297   
    14,
  298    298   
)
  299    299   
.with_xml_name("alternatePathHintSet");
  300    300   
static NETWORKINSIGHTSANALYSIS_MEMBER_SUGGESTED_ACCOUNTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  301    301   
    ::aws_smithy_schema::ShapeId::from_static(
  302    302   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$SuggestedAccounts",
  303    303   
        "com.amazonaws.ec2",
  304    304   
        "NetworkInsightsAnalysis",
  305    305   
    ),
  306    306   
    ::aws_smithy_schema::ShapeType::List,
  307         -
    "suggested_accounts",
         307  +
    "SuggestedAccounts",
  308    308   
    15,
  309    309   
)
  310    310   
.with_xml_name("suggestedAccountSet");
  311    311   
static NETWORKINSIGHTSANALYSIS_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  312    312   
    ::aws_smithy_schema::ShapeId::from_static(
  313    313   
        "com.amazonaws.ec2#NetworkInsightsAnalysis$Tags",
  314    314   
        "com.amazonaws.ec2",
  315    315   
        "NetworkInsightsAnalysis",
  316    316   
    ),
  317    317   
    ::aws_smithy_schema::ShapeType::List,
  318         -
    "tags",
         318  +
    "Tags",
  319    319   
    16,
  320    320   
)
  321    321   
.with_xml_name("tagSet");
  322    322   
static NETWORKINSIGHTSANALYSIS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  323    323   
    NETWORKINSIGHTSANALYSIS_SCHEMA_ID,
  324    324   
    ::aws_smithy_schema::ShapeType::Structure,
  325    325   
    &[
  326    326   
        &NETWORKINSIGHTSANALYSIS_MEMBER_NETWORK_INSIGHTS_ANALYSIS_ID,
  327    327   
        &NETWORKINSIGHTSANALYSIS_MEMBER_NETWORK_INSIGHTS_ANALYSIS_ARN,
  328    328   
        &NETWORKINSIGHTSANALYSIS_MEMBER_NETWORK_INSIGHTS_PATH_ID,
@@ -453,453 +674,630 @@
  473    473   
                    }
  474    474   
                    Ok(())
  475    475   
                },
  476    476   
            )?;
  477    477   
        }
  478    478   
        Ok(())
  479    479   
    }
  480    480   
}
  481    481   
impl NetworkInsightsAnalysis {
  482    482   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  483         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  484         -
        deserializer: &mut D,
         483  +
    pub fn deserialize(
         484  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  485    485   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  486    486   
        #[allow(unused_variables, unused_mut)]
  487    487   
        let mut builder = Self::builder();
  488    488   
        #[allow(
  489    489   
            unused_variables,
  490    490   
            unreachable_code,
  491    491   
            clippy::single_match,
  492    492   
            clippy::match_single_binding,
  493    493   
            clippy::diverging_sub_expression
  494    494   
        )]
  495         -
        deserializer.read_struct(&NETWORKINSIGHTSANALYSIS_SCHEMA, (), |_, member, deser| {
         495  +
        deserializer.read_struct(&NETWORKINSIGHTSANALYSIS_SCHEMA, &mut |member, deser| {
  496    496   
            match member.member_index() {
  497    497   
                Some(0) => {
  498    498   
                    builder.network_insights_analysis_id = Some(deser.read_string(member)?);
  499    499   
                }
  500    500   
                Some(1) => {
  501    501   
                    builder.network_insights_analysis_arn = Some(deser.read_string(member)?);
  502    502   
                }
  503    503   
                Some(2) => {
  504    504   
                    builder.network_insights_path_id = Some(deser.read_string(member)?);
  505    505   
                }
  506    506   
                Some(3) => {
  507         -
                    builder.additional_accounts = Some({
  508         -
                        let container = if let Some(cap) = deser.container_size() {
  509         -
                            Vec::with_capacity(cap)
  510         -
                        } else {
  511         -
                            Vec::new()
  512         -
                        };
  513         -
                        deser.read_list(member, container, |mut list, deser| {
  514         -
                            list.push(deser.read_string(member)?);
  515         -
                            Ok(list)
  516         -
                        })?
  517         -
                    });
         507  +
                    builder.additional_accounts = Some(deser.read_string_list(member)?);
  518    508   
                }
  519    509   
                Some(4) => {
  520         -
                    builder.filter_in_arns = Some({
  521         -
                        let container = if let Some(cap) = deser.container_size() {
  522         -
                            Vec::with_capacity(cap)
  523         -
                        } else {
  524         -
                            Vec::new()
  525         -
                        };
  526         -
                        deser.read_list(member, container, |mut list, deser| {
  527         -
                            list.push(deser.read_string(member)?);
  528         -
                            Ok(list)
  529         -
                        })?
  530         -
                    });
         510  +
                    builder.filter_in_arns = Some(deser.read_string_list(member)?);
  531    511   
                }
  532    512   
                Some(5) => {
  533         -
                    builder.filter_out_arns = Some({
  534         -
                        let container = if let Some(cap) = deser.container_size() {
  535         -
                            Vec::with_capacity(cap)
  536         -
                        } else {
  537         -
                            Vec::new()
  538         -
                        };
  539         -
                        deser.read_list(member, container, |mut list, deser| {
  540         -
                            list.push(deser.read_string(member)?);
  541         -
                            Ok(list)
  542         -
                        })?
  543         -
                    });
         513  +
                    builder.filter_out_arns = Some(deser.read_string_list(member)?);
  544    514   
                }
  545    515   
                Some(6) => {
  546    516   
                    builder.start_date = Some(deser.read_timestamp(member)?);
  547    517   
                }
  548    518   
                Some(7) => {
  549    519   
                    builder.status = Some(crate::types::AnalysisStatus::from(deser.read_string(member)?.as_str()));
  550    520   
                }
  551    521   
                Some(8) => {
  552    522   
                    builder.status_message = Some(deser.read_string(member)?);
  553    523   
                }
  554    524   
                Some(9) => {
  555    525   
                    builder.warning_message = Some(deser.read_string(member)?);
  556    526   
                }
  557    527   
                Some(10) => {
  558    528   
                    builder.network_path_found = Some(deser.read_boolean(member)?);
  559    529   
                }
  560    530   
                Some(11) => {
  561    531   
                    builder.forward_path_components = Some({
  562         -
                        let container = if let Some(cap) = deser.container_size() {
  563         -
                            Vec::with_capacity(cap)
  564         -
                        } else {
  565         -
                            Vec::new()
  566         -
                        };
  567         -
                        deser.read_list(member, container, |mut list, deser| {
  568         -
                            list.push(crate::types::PathComponent::deserialize(deser)?);
  569         -
                            Ok(list)
  570         -
                        })?
         532  +
                        let mut container = Vec::new();
         533  +
                        deser.read_list(member, &mut |deser| {
         534  +
                            container.push(crate::types::PathComponent::deserialize(deser)?);
         535  +
                            Ok(())
         536  +
                        })?;
         537  +
                        container
  571    538   
                    });
  572    539   
                }
  573    540   
                Some(12) => {
  574    541   
                    builder.return_path_components = Some({
  575         -
                        let container = if let Some(cap) = deser.container_size() {
  576         -
                            Vec::with_capacity(cap)
  577         -
                        } else {
  578         -
                            Vec::new()
  579         -
                        };
  580         -
                        deser.read_list(member, container, |mut list, deser| {
  581         -
                            list.push(crate::types::PathComponent::deserialize(deser)?);
  582         -
                            Ok(list)
  583         -
                        })?
         542  +
                        let mut container = Vec::new();
         543  +
                        deser.read_list(member, &mut |deser| {
         544  +
                            container.push(crate::types::PathComponent::deserialize(deser)?);
         545  +
                            Ok(())
         546  +
                        })?;
         547  +
                        container
  584    548   
                    });
  585    549   
                }
  586    550   
                Some(13) => {
  587    551   
                    builder.explanations = Some({
  588         -
                        let container = if let Some(cap) = deser.container_size() {
  589         -
                            Vec::with_capacity(cap)
  590         -
                        } else {
  591         -
                            Vec::new()
  592         -
                        };
  593         -
                        deser.read_list(member, container, |mut list, deser| {
  594         -
                            list.push(crate::types::Explanation::deserialize(deser)?);
  595         -
                            Ok(list)
  596         -
                        })?
         552  +
                        let mut container = Vec::new();
         553  +
                        deser.read_list(member, &mut |deser| {
         554  +
                            container.push(crate::types::Explanation::deserialize(deser)?);
         555  +
                            Ok(())
         556  +
                        })?;
         557  +
                        container
  597    558   
                    });
  598    559   
                }
  599    560   
                Some(14) => {
  600    561   
                    builder.alternate_path_hints = Some({
  601         -
                        let container = if let Some(cap) = deser.container_size() {
  602         -
                            Vec::with_capacity(cap)
  603         -
                        } else {
  604         -
                            Vec::new()
  605         -
                        };
  606         -
                        deser.read_list(member, container, |mut list, deser| {
  607         -
                            list.push(crate::types::AlternatePathHint::deserialize(deser)?);
  608         -
                            Ok(list)
  609         -
                        })?
         562  +
                        let mut container = Vec::new();
         563  +
                        deser.read_list(member, &mut |deser| {
         564  +
                            container.push(crate::types::AlternatePathHint::deserialize(deser)?);
         565  +
                            Ok(())
         566  +
                        })?;
         567  +
                        container
  610    568   
                    });
  611    569   
                }
  612    570   
                Some(15) => {
  613         -
                    builder.suggested_accounts = Some({
  614         -
                        let container = if let Some(cap) = deser.container_size() {
  615         -
                            Vec::with_capacity(cap)
  616         -
                        } else {
  617         -
                            Vec::new()
  618         -
                        };
  619         -
                        deser.read_list(member, container, |mut list, deser| {
  620         -
                            list.push(deser.read_string(member)?);
  621         -
                            Ok(list)
  622         -
                        })?
  623         -
                    });
         571  +
                    builder.suggested_accounts = Some(deser.read_string_list(member)?);
  624    572   
                }
  625    573   
                Some(16) => {
  626    574   
                    builder.tags = Some({
  627         -
                        let container = if let Some(cap) = deser.container_size() {
  628         -
                            Vec::with_capacity(cap)
  629         -
                        } else {
  630         -
                            Vec::new()
  631         -
                        };
  632         -
                        deser.read_list(member, container, |mut list, deser| {
  633         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  634         -
                            Ok(list)
  635         -
                        })?
         575  +
                        let mut container = Vec::new();
         576  +
                        deser.read_list(member, &mut |deser| {
         577  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         578  +
                            Ok(())
         579  +
                        })?;
         580  +
                        container
  636    581   
                    });
  637    582   
                }
  638    583   
                _ => {}
  639    584   
            }
  640    585   
            Ok(())
  641    586   
        })?;
  642    587   
        Ok(builder.build())
  643    588   
    }
  644    589   
}
         590  +
impl NetworkInsightsAnalysis {
         591  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         592  +
    pub fn deserialize_with_response(
         593  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         594  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         595  +
        _status: u16,
         596  +
        _body: &[u8],
         597  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         598  +
        Self::deserialize(deserializer)
         599  +
    }
         600  +
}
  645    601   
impl NetworkInsightsAnalysis {
  646    602   
    /// Creates a new builder-style object to manufacture [`NetworkInsightsAnalysis`](crate::types::NetworkInsightsAnalysis).
  647    603   
    pub fn builder() -> crate::types::builders::NetworkInsightsAnalysisBuilder {
  648    604   
        crate::types::builders::NetworkInsightsAnalysisBuilder::default()
  649    605   
    }
  650    606   
}
  651    607   
  652    608   
/// A builder for [`NetworkInsightsAnalysis`](crate::types::NetworkInsightsAnalysis).
  653    609   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  654    610   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_insights_path.rs

@@ -75,75 +270,270 @@
   95     95   
}
   96     96   
static NETWORKINSIGHTSPATH_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   97     97   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInsightsPath", "com.amazonaws.ec2", "NetworkInsightsPath");
   98     98   
static NETWORKINSIGHTSPATH_MEMBER_NETWORK_INSIGHTS_PATH_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static(
  100    100   
        "com.amazonaws.ec2#NetworkInsightsPath$NetworkInsightsPathId",
  101    101   
        "com.amazonaws.ec2",
  102    102   
        "NetworkInsightsPath",
  103    103   
    ),
  104    104   
    ::aws_smithy_schema::ShapeType::String,
  105         -
    "network_insights_path_id",
         105  +
    "NetworkInsightsPathId",
  106    106   
    0,
  107    107   
)
  108    108   
.with_xml_name("networkInsightsPathId");
  109    109   
static NETWORKINSIGHTSPATH_MEMBER_NETWORK_INSIGHTS_PATH_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.ec2#NetworkInsightsPath$NetworkInsightsPathArn",
  112    112   
        "com.amazonaws.ec2",
  113    113   
        "NetworkInsightsPath",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "network_insights_path_arn",
         116  +
    "NetworkInsightsPathArn",
  117    117   
    1,
  118    118   
)
  119    119   
.with_xml_name("networkInsightsPathArn");
  120    120   
static NETWORKINSIGHTSPATH_MEMBER_CREATED_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  121    121   
    ::aws_smithy_schema::ShapeId::from_static(
  122    122   
        "com.amazonaws.ec2#NetworkInsightsPath$CreatedDate",
  123    123   
        "com.amazonaws.ec2",
  124    124   
        "NetworkInsightsPath",
  125    125   
    ),
  126    126   
    ::aws_smithy_schema::ShapeType::Timestamp,
  127         -
    "created_date",
         127  +
    "CreatedDate",
  128    128   
    2,
  129    129   
)
  130    130   
.with_xml_name("createdDate");
  131    131   
static NETWORKINSIGHTSPATH_MEMBER_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  132    132   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInsightsPath$Source", "com.amazonaws.ec2", "NetworkInsightsPath"),
  133    133   
    ::aws_smithy_schema::ShapeType::String,
  134         -
    "source",
         134  +
    "Source",
  135    135   
    3,
  136    136   
)
  137    137   
.with_xml_name("source");
  138    138   
static NETWORKINSIGHTSPATH_MEMBER_DESTINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  139    139   
    ::aws_smithy_schema::ShapeId::from_static(
  140    140   
        "com.amazonaws.ec2#NetworkInsightsPath$Destination",
  141    141   
        "com.amazonaws.ec2",
  142    142   
        "NetworkInsightsPath",
  143    143   
    ),
  144    144   
    ::aws_smithy_schema::ShapeType::String,
  145         -
    "destination",
         145  +
    "Destination",
  146    146   
    4,
  147    147   
)
  148    148   
.with_xml_name("destination");
  149    149   
static NETWORKINSIGHTSPATH_MEMBER_SOURCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static(
  151    151   
        "com.amazonaws.ec2#NetworkInsightsPath$SourceArn",
  152    152   
        "com.amazonaws.ec2",
  153    153   
        "NetworkInsightsPath",
  154    154   
    ),
  155    155   
    ::aws_smithy_schema::ShapeType::String,
  156         -
    "source_arn",
         156  +
    "SourceArn",
  157    157   
    5,
  158    158   
)
  159    159   
.with_xml_name("sourceArn");
  160    160   
static NETWORKINSIGHTSPATH_MEMBER_DESTINATION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  161    161   
    ::aws_smithy_schema::ShapeId::from_static(
  162    162   
        "com.amazonaws.ec2#NetworkInsightsPath$DestinationArn",
  163    163   
        "com.amazonaws.ec2",
  164    164   
        "NetworkInsightsPath",
  165    165   
    ),
  166    166   
    ::aws_smithy_schema::ShapeType::String,
  167         -
    "destination_arn",
         167  +
    "DestinationArn",
  168    168   
    6,
  169    169   
)
  170    170   
.with_xml_name("destinationArn");
  171    171   
static NETWORKINSIGHTSPATH_MEMBER_SOURCE_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  172    172   
    ::aws_smithy_schema::ShapeId::from_static(
  173    173   
        "com.amazonaws.ec2#NetworkInsightsPath$SourceIp",
  174    174   
        "com.amazonaws.ec2",
  175    175   
        "NetworkInsightsPath",
  176    176   
    ),
  177    177   
    ::aws_smithy_schema::ShapeType::String,
  178         -
    "source_ip",
         178  +
    "SourceIp",
  179    179   
    7,
  180    180   
)
  181    181   
.with_xml_name("sourceIp");
  182    182   
static NETWORKINSIGHTSPATH_MEMBER_DESTINATION_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  183    183   
    ::aws_smithy_schema::ShapeId::from_static(
  184    184   
        "com.amazonaws.ec2#NetworkInsightsPath$DestinationIp",
  185    185   
        "com.amazonaws.ec2",
  186    186   
        "NetworkInsightsPath",
  187    187   
    ),
  188    188   
    ::aws_smithy_schema::ShapeType::String,
  189         -
    "destination_ip",
         189  +
    "DestinationIp",
  190    190   
    8,
  191    191   
)
  192    192   
.with_xml_name("destinationIp");
  193    193   
static NETWORKINSIGHTSPATH_MEMBER_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  194    194   
    ::aws_smithy_schema::ShapeId::from_static(
  195    195   
        "com.amazonaws.ec2#NetworkInsightsPath$Protocol",
  196    196   
        "com.amazonaws.ec2",
  197    197   
        "NetworkInsightsPath",
  198    198   
    ),
  199    199   
    ::aws_smithy_schema::ShapeType::String,
  200         -
    "protocol",
         200  +
    "Protocol",
  201    201   
    9,
  202    202   
)
  203    203   
.with_xml_name("protocol");
  204    204   
static NETWORKINSIGHTSPATH_MEMBER_DESTINATION_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  205    205   
    ::aws_smithy_schema::ShapeId::from_static(
  206    206   
        "com.amazonaws.ec2#NetworkInsightsPath$DestinationPort",
  207    207   
        "com.amazonaws.ec2",
  208    208   
        "NetworkInsightsPath",
  209    209   
    ),
  210    210   
    ::aws_smithy_schema::ShapeType::Integer,
  211         -
    "destination_port",
         211  +
    "DestinationPort",
  212    212   
    10,
  213    213   
)
  214    214   
.with_xml_name("destinationPort");
  215    215   
static NETWORKINSIGHTSPATH_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  216    216   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInsightsPath$Tags", "com.amazonaws.ec2", "NetworkInsightsPath"),
  217    217   
    ::aws_smithy_schema::ShapeType::List,
  218         -
    "tags",
         218  +
    "Tags",
  219    219   
    11,
  220    220   
)
  221    221   
.with_xml_name("tagSet");
  222    222   
static NETWORKINSIGHTSPATH_MEMBER_FILTER_AT_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  223    223   
    ::aws_smithy_schema::ShapeId::from_static(
  224    224   
        "com.amazonaws.ec2#NetworkInsightsPath$FilterAtSource",
  225    225   
        "com.amazonaws.ec2",
  226    226   
        "NetworkInsightsPath",
  227    227   
    ),
  228    228   
    ::aws_smithy_schema::ShapeType::Structure,
  229         -
    "filter_at_source",
         229  +
    "FilterAtSource",
  230    230   
    12,
  231    231   
)
  232    232   
.with_xml_name("filterAtSource");
  233    233   
static NETWORKINSIGHTSPATH_MEMBER_FILTER_AT_DESTINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  234    234   
    ::aws_smithy_schema::ShapeId::from_static(
  235    235   
        "com.amazonaws.ec2#NetworkInsightsPath$FilterAtDestination",
  236    236   
        "com.amazonaws.ec2",
  237    237   
        "NetworkInsightsPath",
  238    238   
    ),
  239    239   
    ::aws_smithy_schema::ShapeType::Structure,
  240         -
    "filter_at_destination",
         240  +
    "FilterAtDestination",
  241    241   
    13,
  242    242   
)
  243    243   
.with_xml_name("filterAtDestination");
  244    244   
static NETWORKINSIGHTSPATH_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  245    245   
    NETWORKINSIGHTSPATH_SCHEMA_ID,
  246    246   
    ::aws_smithy_schema::ShapeType::Structure,
  247    247   
    &[
  248    248   
        &NETWORKINSIGHTSPATH_MEMBER_NETWORK_INSIGHTS_PATH_ID,
  249    249   
        &NETWORKINSIGHTSPATH_MEMBER_NETWORK_INSIGHTS_PATH_ARN,
  250    250   
        &NETWORKINSIGHTSPATH_MEMBER_CREATED_DATE,
@@ -299,299 +431,439 @@
  319    319   
            ser.write_struct(&NETWORKINSIGHTSPATH_MEMBER_FILTER_AT_SOURCE, val)?;
  320    320   
        }
  321    321   
        if let Some(ref val) = self.filter_at_destination {
  322    322   
            ser.write_struct(&NETWORKINSIGHTSPATH_MEMBER_FILTER_AT_DESTINATION, val)?;
  323    323   
        }
  324    324   
        Ok(())
  325    325   
    }
  326    326   
}
  327    327   
impl NetworkInsightsPath {
  328    328   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  329         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  330         -
        deserializer: &mut D,
         329  +
    pub fn deserialize(
         330  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  331    331   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  332    332   
        #[allow(unused_variables, unused_mut)]
  333    333   
        let mut builder = Self::builder();
  334    334   
        #[allow(
  335    335   
            unused_variables,
  336    336   
            unreachable_code,
  337    337   
            clippy::single_match,
  338    338   
            clippy::match_single_binding,
  339    339   
            clippy::diverging_sub_expression
  340    340   
        )]
  341         -
        deserializer.read_struct(&NETWORKINSIGHTSPATH_SCHEMA, (), |_, member, deser| {
         341  +
        deserializer.read_struct(&NETWORKINSIGHTSPATH_SCHEMA, &mut |member, deser| {
  342    342   
            match member.member_index() {
  343    343   
                Some(0) => {
  344    344   
                    builder.network_insights_path_id = Some(deser.read_string(member)?);
  345    345   
                }
  346    346   
                Some(1) => {
  347    347   
                    builder.network_insights_path_arn = Some(deser.read_string(member)?);
  348    348   
                }
  349    349   
                Some(2) => {
  350    350   
                    builder.created_date = Some(deser.read_timestamp(member)?);
  351    351   
                }
  352    352   
                Some(3) => {
  353    353   
                    builder.source = Some(deser.read_string(member)?);
  354    354   
                }
  355    355   
                Some(4) => {
  356    356   
                    builder.destination = Some(deser.read_string(member)?);
  357    357   
                }
  358    358   
                Some(5) => {
  359    359   
                    builder.source_arn = Some(deser.read_string(member)?);
  360    360   
                }
  361    361   
                Some(6) => {
  362    362   
                    builder.destination_arn = Some(deser.read_string(member)?);
  363    363   
                }
  364    364   
                Some(7) => {
  365    365   
                    builder.source_ip = Some(deser.read_string(member)?);
  366    366   
                }
  367    367   
                Some(8) => {
  368    368   
                    builder.destination_ip = Some(deser.read_string(member)?);
  369    369   
                }
  370    370   
                Some(9) => {
  371    371   
                    builder.protocol = Some(crate::types::Protocol::from(deser.read_string(member)?.as_str()));
  372    372   
                }
  373    373   
                Some(10) => {
  374    374   
                    builder.destination_port = Some(deser.read_integer(member)?);
  375    375   
                }
  376    376   
                Some(11) => {
  377    377   
                    builder.tags = Some({
  378         -
                        let container = if let Some(cap) = deser.container_size() {
  379         -
                            Vec::with_capacity(cap)
  380         -
                        } else {
  381         -
                            Vec::new()
  382         -
                        };
  383         -
                        deser.read_list(member, container, |mut list, deser| {
  384         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  385         -
                            Ok(list)
  386         -
                        })?
         378  +
                        let mut container = Vec::new();
         379  +
                        deser.read_list(member, &mut |deser| {
         380  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         381  +
                            Ok(())
         382  +
                        })?;
         383  +
                        container
  387    384   
                    });
  388    385   
                }
  389    386   
                Some(12) => {
  390    387   
                    builder.filter_at_source = Some(crate::types::PathFilter::deserialize(deser)?);
  391    388   
                }
  392    389   
                Some(13) => {
  393    390   
                    builder.filter_at_destination = Some(crate::types::PathFilter::deserialize(deser)?);
  394    391   
                }
  395    392   
                _ => {}
  396    393   
            }
  397    394   
            Ok(())
  398    395   
        })?;
  399    396   
        Ok(builder.build())
  400    397   
    }
  401    398   
}
         399  +
impl NetworkInsightsPath {
         400  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         401  +
    pub fn deserialize_with_response(
         402  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         403  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         404  +
        _status: u16,
         405  +
        _body: &[u8],
         406  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         407  +
        Self::deserialize(deserializer)
         408  +
    }
         409  +
}
  402    410   
impl NetworkInsightsPath {
  403    411   
    /// Creates a new builder-style object to manufacture [`NetworkInsightsPath`](crate::types::NetworkInsightsPath).
  404    412   
    pub fn builder() -> crate::types::builders::NetworkInsightsPathBuilder {
  405    413   
        crate::types::builders::NetworkInsightsPathBuilder::default()
  406    414   
    }
  407    415   
}
  408    416   
  409    417   
/// A builder for [`NetworkInsightsPath`](crate::types::NetworkInsightsPath).
  410    418   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  411    419   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_interface.rs

@@ -185,185 +511,511 @@
  205    205   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.associated_subnets.is_none()`.
  206    206   
    pub fn associated_subnets(&self) -> &[::std::string::String] {
  207    207   
        self.associated_subnets.as_deref().unwrap_or_default()
  208    208   
    }
  209    209   
}
  210    210   
static NETWORKINTERFACE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  211    211   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface", "com.amazonaws.ec2", "NetworkInterface");
  212    212   
static NETWORKINTERFACE_MEMBER_ASSOCIATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  213    213   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$Association", "com.amazonaws.ec2", "NetworkInterface"),
  214    214   
    ::aws_smithy_schema::ShapeType::Structure,
  215         -
    "association",
         215  +
    "Association",
  216    216   
    0,
  217    217   
)
  218    218   
.with_xml_name("association");
  219    219   
static NETWORKINTERFACE_MEMBER_ATTACHMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  220    220   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$Attachment", "com.amazonaws.ec2", "NetworkInterface"),
  221    221   
    ::aws_smithy_schema::ShapeType::Structure,
  222         -
    "attachment",
         222  +
    "Attachment",
  223    223   
    1,
  224    224   
)
  225    225   
.with_xml_name("attachment");
  226    226   
static NETWORKINTERFACE_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  227    227   
    ::aws_smithy_schema::ShapeId::from_static(
  228    228   
        "com.amazonaws.ec2#NetworkInterface$AvailabilityZone",
  229    229   
        "com.amazonaws.ec2",
  230    230   
        "NetworkInterface",
  231    231   
    ),
  232    232   
    ::aws_smithy_schema::ShapeType::String,
  233         -
    "availability_zone",
         233  +
    "AvailabilityZone",
  234    234   
    2,
  235    235   
)
  236    236   
.with_xml_name("availabilityZone");
  237    237   
static NETWORKINTERFACE_MEMBER_CONNECTION_TRACKING_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  238    238   
    ::aws_smithy_schema::ShapeId::from_static(
  239    239   
        "com.amazonaws.ec2#NetworkInterface$ConnectionTrackingConfiguration",
  240    240   
        "com.amazonaws.ec2",
  241    241   
        "NetworkInterface",
  242    242   
    ),
  243    243   
    ::aws_smithy_schema::ShapeType::Structure,
  244         -
    "connection_tracking_configuration",
         244  +
    "ConnectionTrackingConfiguration",
  245    245   
    3,
  246    246   
)
  247    247   
.with_xml_name("connectionTrackingConfiguration");
  248    248   
static NETWORKINTERFACE_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  249    249   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$Description", "com.amazonaws.ec2", "NetworkInterface"),
  250    250   
    ::aws_smithy_schema::ShapeType::String,
  251         -
    "description",
         251  +
    "Description",
  252    252   
    4,
  253    253   
)
  254    254   
.with_xml_name("description");
  255    255   
static NETWORKINTERFACE_MEMBER_GROUPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  256    256   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$Groups", "com.amazonaws.ec2", "NetworkInterface"),
  257    257   
    ::aws_smithy_schema::ShapeType::List,
  258         -
    "groups",
         258  +
    "Groups",
  259    259   
    5,
  260    260   
)
  261    261   
.with_xml_name("groupSet");
  262    262   
static NETWORKINTERFACE_MEMBER_INTERFACE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  263    263   
    ::aws_smithy_schema::ShapeId::from_static(
  264    264   
        "com.amazonaws.ec2#NetworkInterface$InterfaceType",
  265    265   
        "com.amazonaws.ec2",
  266    266   
        "NetworkInterface",
  267    267   
    ),
  268    268   
    ::aws_smithy_schema::ShapeType::String,
  269         -
    "interface_type",
         269  +
    "InterfaceType",
  270    270   
    6,
  271    271   
)
  272    272   
.with_xml_name("interfaceType");
  273    273   
static NETWORKINTERFACE_MEMBER_IPV6_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  274    274   
    ::aws_smithy_schema::ShapeId::from_static(
  275    275   
        "com.amazonaws.ec2#NetworkInterface$Ipv6Addresses",
  276    276   
        "com.amazonaws.ec2",
  277    277   
        "NetworkInterface",
  278    278   
    ),
  279    279   
    ::aws_smithy_schema::ShapeType::List,
  280         -
    "ipv6_addresses",
         280  +
    "Ipv6Addresses",
  281    281   
    7,
  282    282   
)
  283    283   
.with_xml_name("ipv6AddressesSet");
  284    284   
static NETWORKINTERFACE_MEMBER_MAC_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  285    285   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$MacAddress", "com.amazonaws.ec2", "NetworkInterface"),
  286    286   
    ::aws_smithy_schema::ShapeType::String,
  287         -
    "mac_address",
         287  +
    "MacAddress",
  288    288   
    8,
  289    289   
)
  290    290   
.with_xml_name("macAddress");
  291    291   
static NETWORKINTERFACE_MEMBER_NETWORK_INTERFACE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  292    292   
    ::aws_smithy_schema::ShapeId::from_static(
  293    293   
        "com.amazonaws.ec2#NetworkInterface$NetworkInterfaceId",
  294    294   
        "com.amazonaws.ec2",
  295    295   
        "NetworkInterface",
  296    296   
    ),
  297    297   
    ::aws_smithy_schema::ShapeType::String,
  298         -
    "network_interface_id",
         298  +
    "NetworkInterfaceId",
  299    299   
    9,
  300    300   
)
  301    301   
.with_xml_name("networkInterfaceId");
  302    302   
static NETWORKINTERFACE_MEMBER_OUTPOST_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  303    303   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$OutpostArn", "com.amazonaws.ec2", "NetworkInterface"),
  304    304   
    ::aws_smithy_schema::ShapeType::String,
  305         -
    "outpost_arn",
         305  +
    "OutpostArn",
  306    306   
    10,
  307    307   
)
  308    308   
.with_xml_name("outpostArn");
  309    309   
static NETWORKINTERFACE_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  310    310   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$OwnerId", "com.amazonaws.ec2", "NetworkInterface"),
  311    311   
    ::aws_smithy_schema::ShapeType::String,
  312         -
    "owner_id",
         312  +
    "OwnerId",
  313    313   
    11,
  314    314   
)
  315    315   
.with_xml_name("ownerId");
  316    316   
static NETWORKINTERFACE_MEMBER_PRIVATE_DNS_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  317    317   
    ::aws_smithy_schema::ShapeId::from_static(
  318    318   
        "com.amazonaws.ec2#NetworkInterface$PrivateDnsName",
  319    319   
        "com.amazonaws.ec2",
  320    320   
        "NetworkInterface",
  321    321   
    ),
  322    322   
    ::aws_smithy_schema::ShapeType::String,
  323         -
    "private_dns_name",
         323  +
    "PrivateDnsName",
  324    324   
    12,
  325    325   
)
  326    326   
.with_xml_name("privateDnsName");
  327    327   
static NETWORKINTERFACE_MEMBER_PUBLIC_DNS_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  328    328   
    ::aws_smithy_schema::ShapeId::from_static(
  329    329   
        "com.amazonaws.ec2#NetworkInterface$PublicDnsName",
  330    330   
        "com.amazonaws.ec2",
  331    331   
        "NetworkInterface",
  332    332   
    ),
  333    333   
    ::aws_smithy_schema::ShapeType::String,
  334         -
    "public_dns_name",
         334  +
    "PublicDnsName",
  335    335   
    13,
  336    336   
)
  337    337   
.with_xml_name("publicDnsName");
  338    338   
static NETWORKINTERFACE_MEMBER_PUBLIC_IP_DNS_NAME_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  339    339   
    ::aws_smithy_schema::ShapeId::from_static(
  340    340   
        "com.amazonaws.ec2#NetworkInterface$PublicIpDnsNameOptions",
  341    341   
        "com.amazonaws.ec2",
  342    342   
        "NetworkInterface",
  343    343   
    ),
  344    344   
    ::aws_smithy_schema::ShapeType::Structure,
  345         -
    "public_ip_dns_name_options",
         345  +
    "PublicIpDnsNameOptions",
  346    346   
    14,
  347    347   
)
  348    348   
.with_xml_name("publicIpDnsNameOptions");
  349    349   
static NETWORKINTERFACE_MEMBER_PRIVATE_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  350    350   
    ::aws_smithy_schema::ShapeId::from_static(
  351    351   
        "com.amazonaws.ec2#NetworkInterface$PrivateIpAddress",
  352    352   
        "com.amazonaws.ec2",
  353    353   
        "NetworkInterface",
  354    354   
    ),
  355    355   
    ::aws_smithy_schema::ShapeType::String,
  356         -
    "private_ip_address",
         356  +
    "PrivateIpAddress",
  357    357   
    15,
  358    358   
)
  359    359   
.with_xml_name("privateIpAddress");
  360    360   
static NETWORKINTERFACE_MEMBER_PRIVATE_IP_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  361    361   
    ::aws_smithy_schema::ShapeId::from_static(
  362    362   
        "com.amazonaws.ec2#NetworkInterface$PrivateIpAddresses",
  363    363   
        "com.amazonaws.ec2",
  364    364   
        "NetworkInterface",
  365    365   
    ),
  366    366   
    ::aws_smithy_schema::ShapeType::List,
  367         -
    "private_ip_addresses",
         367  +
    "PrivateIpAddresses",
  368    368   
    16,
  369    369   
)
  370    370   
.with_xml_name("privateIpAddressesSet");
  371    371   
static NETWORKINTERFACE_MEMBER_IPV4_PREFIXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  372    372   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$Ipv4Prefixes", "com.amazonaws.ec2", "NetworkInterface"),
  373    373   
    ::aws_smithy_schema::ShapeType::List,
  374         -
    "ipv4_prefixes",
         374  +
    "Ipv4Prefixes",
  375    375   
    17,
  376    376   
)
  377    377   
.with_xml_name("ipv4PrefixSet");
  378    378   
static NETWORKINTERFACE_MEMBER_IPV6_PREFIXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  379    379   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$Ipv6Prefixes", "com.amazonaws.ec2", "NetworkInterface"),
  380    380   
    ::aws_smithy_schema::ShapeType::List,
  381         -
    "ipv6_prefixes",
         381  +
    "Ipv6Prefixes",
  382    382   
    18,
  383    383   
)
  384    384   
.with_xml_name("ipv6PrefixSet");
  385    385   
static NETWORKINTERFACE_MEMBER_REQUESTER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  386    386   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$RequesterId", "com.amazonaws.ec2", "NetworkInterface"),
  387    387   
    ::aws_smithy_schema::ShapeType::String,
  388         -
    "requester_id",
         388  +
    "RequesterId",
  389    389   
    19,
  390    390   
)
  391    391   
.with_xml_name("requesterId");
  392    392   
static NETWORKINTERFACE_MEMBER_REQUESTER_MANAGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  393    393   
    ::aws_smithy_schema::ShapeId::from_static(
  394    394   
        "com.amazonaws.ec2#NetworkInterface$RequesterManaged",
  395    395   
        "com.amazonaws.ec2",
  396    396   
        "NetworkInterface",
  397    397   
    ),
  398    398   
    ::aws_smithy_schema::ShapeType::Boolean,
  399         -
    "requester_managed",
         399  +
    "RequesterManaged",
  400    400   
    20,
  401    401   
)
  402    402   
.with_xml_name("requesterManaged");
  403    403   
static NETWORKINTERFACE_MEMBER_SOURCE_DEST_CHECK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  404    404   
    ::aws_smithy_schema::ShapeId::from_static(
  405    405   
        "com.amazonaws.ec2#NetworkInterface$SourceDestCheck",
  406    406   
        "com.amazonaws.ec2",
  407    407   
        "NetworkInterface",
  408    408   
    ),
  409    409   
    ::aws_smithy_schema::ShapeType::Boolean,
  410         -
    "source_dest_check",
         410  +
    "SourceDestCheck",
  411    411   
    21,
  412    412   
)
  413    413   
.with_xml_name("sourceDestCheck");
  414    414   
static NETWORKINTERFACE_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  415    415   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$Status", "com.amazonaws.ec2", "NetworkInterface"),
  416    416   
    ::aws_smithy_schema::ShapeType::String,
  417         -
    "status",
         417  +
    "Status",
  418    418   
    22,
  419    419   
)
  420    420   
.with_xml_name("status");
  421    421   
static NETWORKINTERFACE_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  422    422   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$SubnetId", "com.amazonaws.ec2", "NetworkInterface"),
  423    423   
    ::aws_smithy_schema::ShapeType::String,
  424         -
    "subnet_id",
         424  +
    "SubnetId",
  425    425   
    23,
  426    426   
)
  427    427   
.with_xml_name("subnetId");
  428    428   
static NETWORKINTERFACE_MEMBER_TAG_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  429    429   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$TagSet", "com.amazonaws.ec2", "NetworkInterface"),
  430    430   
    ::aws_smithy_schema::ShapeType::List,
  431         -
    "tag_set",
         431  +
    "TagSet",
  432    432   
    24,
  433    433   
)
  434    434   
.with_xml_name("tagSet");
  435    435   
static NETWORKINTERFACE_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  436    436   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$VpcId", "com.amazonaws.ec2", "NetworkInterface"),
  437    437   
    ::aws_smithy_schema::ShapeType::String,
  438         -
    "vpc_id",
         438  +
    "VpcId",
  439    439   
    25,
  440    440   
)
  441    441   
.with_xml_name("vpcId");
  442    442   
static NETWORKINTERFACE_MEMBER_DENY_ALL_IGW_TRAFFIC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  443    443   
    ::aws_smithy_schema::ShapeId::from_static(
  444    444   
        "com.amazonaws.ec2#NetworkInterface$DenyAllIgwTraffic",
  445    445   
        "com.amazonaws.ec2",
  446    446   
        "NetworkInterface",
  447    447   
    ),
  448    448   
    ::aws_smithy_schema::ShapeType::Boolean,
  449         -
    "deny_all_igw_traffic",
         449  +
    "DenyAllIgwTraffic",
  450    450   
    26,
  451    451   
)
  452    452   
.with_xml_name("denyAllIgwTraffic");
  453    453   
static NETWORKINTERFACE_MEMBER_IPV6_NATIVE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  454    454   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$Ipv6Native", "com.amazonaws.ec2", "NetworkInterface"),
  455    455   
    ::aws_smithy_schema::ShapeType::Boolean,
  456         -
    "ipv6_native",
         456  +
    "Ipv6Native",
  457    457   
    27,
  458    458   
)
  459    459   
.with_xml_name("ipv6Native");
  460    460   
static NETWORKINTERFACE_MEMBER_IPV6_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  461    461   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$Ipv6Address", "com.amazonaws.ec2", "NetworkInterface"),
  462    462   
    ::aws_smithy_schema::ShapeType::String,
  463         -
    "ipv6_address",
         463  +
    "Ipv6Address",
  464    464   
    28,
  465    465   
)
  466    466   
.with_xml_name("ipv6Address");
  467    467   
static NETWORKINTERFACE_MEMBER_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  468    468   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterface$Operator", "com.amazonaws.ec2", "NetworkInterface"),
  469    469   
    ::aws_smithy_schema::ShapeType::Structure,
  470         -
    "operator",
         470  +
    "Operator",
  471    471   
    29,
  472    472   
)
  473    473   
.with_xml_name("operator");
  474    474   
static NETWORKINTERFACE_MEMBER_ASSOCIATED_SUBNETS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  475    475   
    ::aws_smithy_schema::ShapeId::from_static(
  476    476   
        "com.amazonaws.ec2#NetworkInterface$AssociatedSubnets",
  477    477   
        "com.amazonaws.ec2",
  478    478   
        "NetworkInterface",
  479    479   
    ),
  480    480   
    ::aws_smithy_schema::ShapeType::List,
  481         -
    "associated_subnets",
         481  +
    "AssociatedSubnets",
  482    482   
    30,
  483    483   
)
  484    484   
.with_xml_name("associatedSubnetSet");
  485    485   
static NETWORKINTERFACE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  486    486   
    NETWORKINTERFACE_SCHEMA_ID,
  487    487   
    ::aws_smithy_schema::ShapeType::Structure,
  488    488   
    &[
  489    489   
        &NETWORKINTERFACE_MEMBER_ASSOCIATION,
  490    490   
        &NETWORKINTERFACE_MEMBER_ATTACHMENT,
  491    491   
        &NETWORKINTERFACE_MEMBER_AVAILABILITY_ZONE,
@@ -656,656 +899,882 @@
  676    676   
                    }
  677    677   
                    Ok(())
  678    678   
                },
  679    679   
            )?;
  680    680   
        }
  681    681   
        Ok(())
  682    682   
    }
  683    683   
}
  684    684   
impl NetworkInterface {
  685    685   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  686         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  687         -
        deserializer: &mut D,
         686  +
    pub fn deserialize(
         687  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  688    688   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  689    689   
        #[allow(unused_variables, unused_mut)]
  690    690   
        let mut builder = Self::builder();
  691    691   
        #[allow(
  692    692   
            unused_variables,
  693    693   
            unreachable_code,
  694    694   
            clippy::single_match,
  695    695   
            clippy::match_single_binding,
  696    696   
            clippy::diverging_sub_expression
  697    697   
        )]
  698         -
        deserializer.read_struct(&NETWORKINTERFACE_SCHEMA, (), |_, member, deser| {
         698  +
        deserializer.read_struct(&NETWORKINTERFACE_SCHEMA, &mut |member, deser| {
  699    699   
            match member.member_index() {
  700    700   
                Some(0) => {
  701    701   
                    builder.association = Some(crate::types::NetworkInterfaceAssociation::deserialize(deser)?);
  702    702   
                }
  703    703   
                Some(1) => {
  704    704   
                    builder.attachment = Some(crate::types::NetworkInterfaceAttachment::deserialize(deser)?);
  705    705   
                }
  706    706   
                Some(2) => {
  707    707   
                    builder.availability_zone = Some(deser.read_string(member)?);
  708    708   
                }
  709    709   
                Some(3) => {
  710    710   
                    builder.connection_tracking_configuration = Some(crate::types::ConnectionTrackingConfiguration::deserialize(deser)?);
  711    711   
                }
  712    712   
                Some(4) => {
  713    713   
                    builder.description = Some(deser.read_string(member)?);
  714    714   
                }
  715    715   
                Some(5) => {
  716    716   
                    builder.groups = Some({
  717         -
                        let container = if let Some(cap) = deser.container_size() {
  718         -
                            Vec::with_capacity(cap)
  719         -
                        } else {
  720         -
                            Vec::new()
  721         -
                        };
  722         -
                        deser.read_list(member, container, |mut list, deser| {
  723         -
                            list.push(crate::types::GroupIdentifier::deserialize(deser)?);
  724         -
                            Ok(list)
  725         -
                        })?
         717  +
                        let mut container = Vec::new();
         718  +
                        deser.read_list(member, &mut |deser| {
         719  +
                            container.push(crate::types::GroupIdentifier::deserialize(deser)?);
         720  +
                            Ok(())
         721  +
                        })?;
         722  +
                        container
  726    723   
                    });
  727    724   
                }
  728    725   
                Some(6) => {
  729    726   
                    builder.interface_type = Some(crate::types::NetworkInterfaceType::from(deser.read_string(member)?.as_str()));
  730    727   
                }
  731    728   
                Some(7) => {
  732    729   
                    builder.ipv6_addresses = Some({
  733         -
                        let container = if let Some(cap) = deser.container_size() {
  734         -
                            Vec::with_capacity(cap)
  735         -
                        } else {
  736         -
                            Vec::new()
  737         -
                        };
  738         -
                        deser.read_list(member, container, |mut list, deser| {
  739         -
                            list.push(crate::types::NetworkInterfaceIpv6Address::deserialize(deser)?);
  740         -
                            Ok(list)
  741         -
                        })?
         730  +
                        let mut container = Vec::new();
         731  +
                        deser.read_list(member, &mut |deser| {
         732  +
                            container.push(crate::types::NetworkInterfaceIpv6Address::deserialize(deser)?);
         733  +
                            Ok(())
         734  +
                        })?;
         735  +
                        container
  742    736   
                    });
  743    737   
                }
  744    738   
                Some(8) => {
  745    739   
                    builder.mac_address = Some(deser.read_string(member)?);
  746    740   
                }
  747    741   
                Some(9) => {
  748    742   
                    builder.network_interface_id = Some(deser.read_string(member)?);
  749    743   
                }
  750    744   
                Some(10) => {
  751    745   
                    builder.outpost_arn = Some(deser.read_string(member)?);
  752    746   
                }
  753    747   
                Some(11) => {
  754    748   
                    builder.owner_id = Some(deser.read_string(member)?);
  755    749   
                }
  756    750   
                Some(12) => {
  757    751   
                    builder.private_dns_name = Some(deser.read_string(member)?);
  758    752   
                }
  759    753   
                Some(13) => {
  760    754   
                    builder.public_dns_name = Some(deser.read_string(member)?);
  761    755   
                }
  762    756   
                Some(14) => {
  763    757   
                    builder.public_ip_dns_name_options = Some(crate::types::PublicIpDnsNameOptions::deserialize(deser)?);
  764    758   
                }
  765    759   
                Some(15) => {
  766    760   
                    builder.private_ip_address = Some(deser.read_string(member)?);
  767    761   
                }
  768    762   
                Some(16) => {
  769    763   
                    builder.private_ip_addresses = Some({
  770         -
                        let container = if let Some(cap) = deser.container_size() {
  771         -
                            Vec::with_capacity(cap)
  772         -
                        } else {
  773         -
                            Vec::new()
  774         -
                        };
  775         -
                        deser.read_list(member, container, |mut list, deser| {
  776         -
                            list.push(crate::types::NetworkInterfacePrivateIpAddress::deserialize(deser)?);
  777         -
                            Ok(list)
  778         -
                        })?
         764  +
                        let mut container = Vec::new();
         765  +
                        deser.read_list(member, &mut |deser| {
         766  +
                            container.push(crate::types::NetworkInterfacePrivateIpAddress::deserialize(deser)?);
         767  +
                            Ok(())
         768  +
                        })?;
         769  +
                        container
  779    770   
                    });
  780    771   
                }
  781    772   
                Some(17) => {
  782    773   
                    builder.ipv4_prefixes = Some({
  783         -
                        let container = if let Some(cap) = deser.container_size() {
  784         -
                            Vec::with_capacity(cap)
  785         -
                        } else {
  786         -
                            Vec::new()
  787         -
                        };
  788         -
                        deser.read_list(member, container, |mut list, deser| {
  789         -
                            list.push(crate::types::Ipv4PrefixSpecification::deserialize(deser)?);
  790         -
                            Ok(list)
  791         -
                        })?
         774  +
                        let mut container = Vec::new();
         775  +
                        deser.read_list(member, &mut |deser| {
         776  +
                            container.push(crate::types::Ipv4PrefixSpecification::deserialize(deser)?);
         777  +
                            Ok(())
         778  +
                        })?;
         779  +
                        container
  792    780   
                    });
  793    781   
                }
  794    782   
                Some(18) => {
  795    783   
                    builder.ipv6_prefixes = Some({
  796         -
                        let container = if let Some(cap) = deser.container_size() {
  797         -
                            Vec::with_capacity(cap)
  798         -
                        } else {
  799         -
                            Vec::new()
  800         -
                        };
  801         -
                        deser.read_list(member, container, |mut list, deser| {
  802         -
                            list.push(crate::types::Ipv6PrefixSpecification::deserialize(deser)?);
  803         -
                            Ok(list)
  804         -
                        })?
         784  +
                        let mut container = Vec::new();
         785  +
                        deser.read_list(member, &mut |deser| {
         786  +
                            container.push(crate::types::Ipv6PrefixSpecification::deserialize(deser)?);
         787  +
                            Ok(())
         788  +
                        })?;
         789  +
                        container
  805    790   
                    });
  806    791   
                }
  807    792   
                Some(19) => {
  808    793   
                    builder.requester_id = Some(deser.read_string(member)?);
  809    794   
                }
  810    795   
                Some(20) => {
  811    796   
                    builder.requester_managed = Some(deser.read_boolean(member)?);
  812    797   
                }
  813    798   
                Some(21) => {
  814    799   
                    builder.source_dest_check = Some(deser.read_boolean(member)?);
  815    800   
                }
  816    801   
                Some(22) => {
  817    802   
                    builder.status = Some(crate::types::NetworkInterfaceStatus::from(deser.read_string(member)?.as_str()));
  818    803   
                }
  819    804   
                Some(23) => {
  820    805   
                    builder.subnet_id = Some(deser.read_string(member)?);
  821    806   
                }
  822    807   
                Some(24) => {
  823    808   
                    builder.tag_set = Some({
  824         -
                        let container = if let Some(cap) = deser.container_size() {
  825         -
                            Vec::with_capacity(cap)
  826         -
                        } else {
  827         -
                            Vec::new()
  828         -
                        };
  829         -
                        deser.read_list(member, container, |mut list, deser| {
  830         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  831         -
                            Ok(list)
  832         -
                        })?
         809  +
                        let mut container = Vec::new();
         810  +
                        deser.read_list(member, &mut |deser| {
         811  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         812  +
                            Ok(())
         813  +
                        })?;
         814  +
                        container
  833    815   
                    });
  834    816   
                }
  835    817   
                Some(25) => {
  836    818   
                    builder.vpc_id = Some(deser.read_string(member)?);
  837    819   
                }
  838    820   
                Some(26) => {
  839    821   
                    builder.deny_all_igw_traffic = Some(deser.read_boolean(member)?);
  840    822   
                }
  841    823   
                Some(27) => {
  842    824   
                    builder.ipv6_native = Some(deser.read_boolean(member)?);
  843    825   
                }
  844    826   
                Some(28) => {
  845    827   
                    builder.ipv6_address = Some(deser.read_string(member)?);
  846    828   
                }
  847    829   
                Some(29) => {
  848    830   
                    builder.operator = Some(crate::types::OperatorResponse::deserialize(deser)?);
  849    831   
                }
  850    832   
                Some(30) => {
  851         -
                    builder.associated_subnets = Some({
  852         -
                        let container = if let Some(cap) = deser.container_size() {
  853         -
                            Vec::with_capacity(cap)
  854         -
                        } else {
  855         -
                            Vec::new()
  856         -
                        };
  857         -
                        deser.read_list(member, container, |mut list, deser| {
  858         -
                            list.push(deser.read_string(member)?);
  859         -
                            Ok(list)
  860         -
                        })?
  861         -
                    });
         833  +
                    builder.associated_subnets = Some(deser.read_string_list(member)?);
  862    834   
                }
  863    835   
                _ => {}
  864    836   
            }
  865    837   
            Ok(())
  866    838   
        })?;
  867    839   
        Ok(builder.build())
  868    840   
    }
  869    841   
}
         842  +
impl NetworkInterface {
         843  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         844  +
    pub fn deserialize_with_response(
         845  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         846  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         847  +
        _status: u16,
         848  +
        _body: &[u8],
         849  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         850  +
        Self::deserialize(deserializer)
         851  +
    }
         852  +
}
  870    853   
impl NetworkInterface {
  871    854   
    /// Creates a new builder-style object to manufacture [`NetworkInterface`](crate::types::NetworkInterface).
  872    855   
    pub fn builder() -> crate::types::builders::NetworkInterfaceBuilder {
  873    856   
        crate::types::builders::NetworkInterfaceBuilder::default()
  874    857   
    }
  875    858   
}
  876    859   
  877    860   
/// A builder for [`NetworkInterface`](crate::types::NetworkInterface).
  878    861   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  879    862   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_interface_association.rs

@@ -36,36 +256,267 @@
   56     56   
    "com.amazonaws.ec2",
   57     57   
    "NetworkInterfaceAssociation",
   58     58   
);
   59     59   
static NETWORKINTERFACEASSOCIATION_MEMBER_ALLOCATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.ec2#NetworkInterfaceAssociation$AllocationId",
   62     62   
        "com.amazonaws.ec2",
   63     63   
        "NetworkInterfaceAssociation",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "allocation_id",
          66  +
    "AllocationId",
   67     67   
    0,
   68     68   
)
   69     69   
.with_xml_name("allocationId");
   70     70   
static NETWORKINTERFACEASSOCIATION_MEMBER_ASSOCIATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.ec2#NetworkInterfaceAssociation$AssociationId",
   73     73   
        "com.amazonaws.ec2",
   74     74   
        "NetworkInterfaceAssociation",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "association_id",
          77  +
    "AssociationId",
   78     78   
    1,
   79     79   
)
   80     80   
.with_xml_name("associationId");
   81     81   
static NETWORKINTERFACEASSOCIATION_MEMBER_IP_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.ec2#NetworkInterfaceAssociation$IpOwnerId",
   84     84   
        "com.amazonaws.ec2",
   85     85   
        "NetworkInterfaceAssociation",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::String,
   88         -
    "ip_owner_id",
          88  +
    "IpOwnerId",
   89     89   
    2,
   90     90   
)
   91     91   
.with_xml_name("ipOwnerId");
   92     92   
static NETWORKINTERFACEASSOCIATION_MEMBER_PUBLIC_DNS_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "com.amazonaws.ec2#NetworkInterfaceAssociation$PublicDnsName",
   95     95   
        "com.amazonaws.ec2",
   96     96   
        "NetworkInterfaceAssociation",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "public_dns_name",
          99  +
    "PublicDnsName",
  100    100   
    3,
  101    101   
)
  102    102   
.with_xml_name("publicDnsName");
  103    103   
static NETWORKINTERFACEASSOCIATION_MEMBER_PUBLIC_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.ec2#NetworkInterfaceAssociation$PublicIp",
  106    106   
        "com.amazonaws.ec2",
  107    107   
        "NetworkInterfaceAssociation",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::String,
  110         -
    "public_ip",
         110  +
    "PublicIp",
  111    111   
    4,
  112    112   
)
  113    113   
.with_xml_name("publicIp");
  114    114   
static NETWORKINTERFACEASSOCIATION_MEMBER_CUSTOMER_OWNED_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "com.amazonaws.ec2#NetworkInterfaceAssociation$CustomerOwnedIp",
  117    117   
        "com.amazonaws.ec2",
  118    118   
        "NetworkInterfaceAssociation",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::String,
  121         -
    "customer_owned_ip",
         121  +
    "CustomerOwnedIp",
  122    122   
    5,
  123    123   
)
  124    124   
.with_xml_name("customerOwnedIp");
  125    125   
static NETWORKINTERFACEASSOCIATION_MEMBER_CARRIER_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "com.amazonaws.ec2#NetworkInterfaceAssociation$CarrierIp",
  128    128   
        "com.amazonaws.ec2",
  129    129   
        "NetworkInterfaceAssociation",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::String,
  132         -
    "carrier_ip",
         132  +
    "CarrierIp",
  133    133   
    6,
  134    134   
)
  135    135   
.with_xml_name("carrierIp");
  136    136   
static NETWORKINTERFACEASSOCIATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  137    137   
    NETWORKINTERFACEASSOCIATION_SCHEMA_ID,
  138    138   
    ::aws_smithy_schema::ShapeType::Structure,
  139    139   
    &[
  140    140   
        &NETWORKINTERFACEASSOCIATION_MEMBER_ALLOCATION_ID,
  141    141   
        &NETWORKINTERFACEASSOCIATION_MEMBER_ASSOCIATION_ID,
  142    142   
        &NETWORKINTERFACEASSOCIATION_MEMBER_IP_OWNER_ID,
  143    143   
        &NETWORKINTERFACEASSOCIATION_MEMBER_PUBLIC_DNS_NAME,
  144    144   
        &NETWORKINTERFACEASSOCIATION_MEMBER_PUBLIC_IP,
  145    145   
        &NETWORKINTERFACEASSOCIATION_MEMBER_CUSTOMER_OWNED_IP,
  146    146   
        &NETWORKINTERFACEASSOCIATION_MEMBER_CARRIER_IP,
  147    147   
    ],
  148    148   
);
  149    149   
impl NetworkInterfaceAssociation {
  150    150   
    /// The schema for this shape.
  151    151   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NETWORKINTERFACEASSOCIATION_SCHEMA;
  152    152   
}
  153    153   
impl ::aws_smithy_schema::serde::SerializableStruct for NetworkInterfaceAssociation {
  154    154   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  155    155   
    fn serialize_members(
  156    156   
        &self,
  157    157   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  158    158   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  159    159   
        if let Some(ref val) = self.allocation_id {
  160    160   
            ser.write_string(&NETWORKINTERFACEASSOCIATION_MEMBER_ALLOCATION_ID, val)?;
  161    161   
        }
  162    162   
        if let Some(ref val) = self.association_id {
  163    163   
            ser.write_string(&NETWORKINTERFACEASSOCIATION_MEMBER_ASSOCIATION_ID, val)?;
  164    164   
        }
  165    165   
        if let Some(ref val) = self.ip_owner_id {
  166    166   
            ser.write_string(&NETWORKINTERFACEASSOCIATION_MEMBER_IP_OWNER_ID, val)?;
  167    167   
        }
  168    168   
        if let Some(ref val) = self.public_dns_name {
  169    169   
            ser.write_string(&NETWORKINTERFACEASSOCIATION_MEMBER_PUBLIC_DNS_NAME, val)?;
  170    170   
        }
  171    171   
        if let Some(ref val) = self.public_ip {
  172    172   
            ser.write_string(&NETWORKINTERFACEASSOCIATION_MEMBER_PUBLIC_IP, val)?;
  173    173   
        }
  174    174   
        if let Some(ref val) = self.customer_owned_ip {
  175    175   
            ser.write_string(&NETWORKINTERFACEASSOCIATION_MEMBER_CUSTOMER_OWNED_IP, val)?;
  176    176   
        }
  177    177   
        if let Some(ref val) = self.carrier_ip {
  178    178   
            ser.write_string(&NETWORKINTERFACEASSOCIATION_MEMBER_CARRIER_IP, val)?;
  179    179   
        }
  180    180   
        Ok(())
  181    181   
    }
  182    182   
}
  183    183   
impl NetworkInterfaceAssociation {
  184    184   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  185         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  186         -
        deserializer: &mut D,
         185  +
    pub fn deserialize(
         186  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  187    187   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  188    188   
        #[allow(unused_variables, unused_mut)]
  189    189   
        let mut builder = Self::builder();
  190    190   
        #[allow(
  191    191   
            unused_variables,
  192    192   
            unreachable_code,
  193    193   
            clippy::single_match,
  194    194   
            clippy::match_single_binding,
  195    195   
            clippy::diverging_sub_expression
  196    196   
        )]
  197         -
        deserializer.read_struct(&NETWORKINTERFACEASSOCIATION_SCHEMA, (), |_, member, deser| {
         197  +
        deserializer.read_struct(&NETWORKINTERFACEASSOCIATION_SCHEMA, &mut |member, deser| {
  198    198   
            match member.member_index() {
  199    199   
                Some(0) => {
  200    200   
                    builder.allocation_id = Some(deser.read_string(member)?);
  201    201   
                }
  202    202   
                Some(1) => {
  203    203   
                    builder.association_id = Some(deser.read_string(member)?);
  204    204   
                }
  205    205   
                Some(2) => {
  206    206   
                    builder.ip_owner_id = Some(deser.read_string(member)?);
  207    207   
                }
  208    208   
                Some(3) => {
  209    209   
                    builder.public_dns_name = Some(deser.read_string(member)?);
  210    210   
                }
  211    211   
                Some(4) => {
  212    212   
                    builder.public_ip = Some(deser.read_string(member)?);
  213    213   
                }
  214    214   
                Some(5) => {
  215    215   
                    builder.customer_owned_ip = Some(deser.read_string(member)?);
  216    216   
                }
  217    217   
                Some(6) => {
  218    218   
                    builder.carrier_ip = Some(deser.read_string(member)?);
  219    219   
                }
  220    220   
                _ => {}
  221    221   
            }
  222    222   
            Ok(())
  223    223   
        })?;
  224    224   
        Ok(builder.build())
  225    225   
    }
  226    226   
}
         227  +
impl NetworkInterfaceAssociation {
         228  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         229  +
    pub fn deserialize_with_response(
         230  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         231  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         232  +
        _status: u16,
         233  +
        _body: &[u8],
         234  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         235  +
        Self::deserialize(deserializer)
         236  +
    }
         237  +
}
  227    238   
impl NetworkInterfaceAssociation {
  228    239   
    /// Creates a new builder-style object to manufacture [`NetworkInterfaceAssociation`](crate::types::NetworkInterfaceAssociation).
  229    240   
    pub fn builder() -> crate::types::builders::NetworkInterfaceAssociationBuilder {
  230    241   
        crate::types::builders::NetworkInterfaceAssociationBuilder::default()
  231    242   
    }
  232    243   
}
  233    244   
  234    245   
/// A builder for [`NetworkInterfaceAssociation`](crate::types::NetworkInterfaceAssociation).
  235    246   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  236    247   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_interface_attachment.rs

@@ -52,52 +211,211 @@
   72     72   
    "com.amazonaws.ec2",
   73     73   
    "NetworkInterfaceAttachment",
   74     74   
);
   75     75   
static NETWORKINTERFACEATTACHMENT_MEMBER_ATTACH_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static(
   77     77   
        "com.amazonaws.ec2#NetworkInterfaceAttachment$AttachTime",
   78     78   
        "com.amazonaws.ec2",
   79     79   
        "NetworkInterfaceAttachment",
   80     80   
    ),
   81     81   
    ::aws_smithy_schema::ShapeType::Timestamp,
   82         -
    "attach_time",
          82  +
    "AttachTime",
   83     83   
    0,
   84     84   
)
   85     85   
.with_xml_name("attachTime");
   86     86   
static NETWORKINTERFACEATTACHMENT_MEMBER_ATTACHMENT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.ec2#NetworkInterfaceAttachment$AttachmentId",
   89     89   
        "com.amazonaws.ec2",
   90     90   
        "NetworkInterfaceAttachment",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::String,
   93         -
    "attachment_id",
          93  +
    "AttachmentId",
   94     94   
    1,
   95     95   
)
   96     96   
.with_xml_name("attachmentId");
   97     97   
static NETWORKINTERFACEATTACHMENT_MEMBER_DELETE_ON_TERMINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.ec2#NetworkInterfaceAttachment$DeleteOnTermination",
  100    100   
        "com.amazonaws.ec2",
  101    101   
        "NetworkInterfaceAttachment",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::Boolean,
  104         -
    "delete_on_termination",
         104  +
    "DeleteOnTermination",
  105    105   
    2,
  106    106   
)
  107    107   
.with_xml_name("deleteOnTermination");
  108    108   
static NETWORKINTERFACEATTACHMENT_MEMBER_DEVICE_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static(
  110    110   
        "com.amazonaws.ec2#NetworkInterfaceAttachment$DeviceIndex",
  111    111   
        "com.amazonaws.ec2",
  112    112   
        "NetworkInterfaceAttachment",
  113    113   
    ),
  114    114   
    ::aws_smithy_schema::ShapeType::Integer,
  115         -
    "device_index",
         115  +
    "DeviceIndex",
  116    116   
    3,
  117    117   
)
  118    118   
.with_xml_name("deviceIndex");
  119    119   
static NETWORKINTERFACEATTACHMENT_MEMBER_NETWORK_CARD_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.ec2#NetworkInterfaceAttachment$NetworkCardIndex",
  122    122   
        "com.amazonaws.ec2",
  123    123   
        "NetworkInterfaceAttachment",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::Integer,
  126         -
    "network_card_index",
         126  +
    "NetworkCardIndex",
  127    127   
    4,
  128    128   
)
  129    129   
.with_xml_name("networkCardIndex");
  130    130   
static NETWORKINTERFACEATTACHMENT_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static(
  132    132   
        "com.amazonaws.ec2#NetworkInterfaceAttachment$InstanceId",
  133    133   
        "com.amazonaws.ec2",
  134    134   
        "NetworkInterfaceAttachment",
  135    135   
    ),
  136    136   
    ::aws_smithy_schema::ShapeType::String,
  137         -
    "instance_id",
         137  +
    "InstanceId",
  138    138   
    5,
  139    139   
)
  140    140   
.with_xml_name("instanceId");
  141    141   
static NETWORKINTERFACEATTACHMENT_MEMBER_INSTANCE_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  142    142   
    ::aws_smithy_schema::ShapeId::from_static(
  143    143   
        "com.amazonaws.ec2#NetworkInterfaceAttachment$InstanceOwnerId",
  144    144   
        "com.amazonaws.ec2",
  145    145   
        "NetworkInterfaceAttachment",
  146    146   
    ),
  147    147   
    ::aws_smithy_schema::ShapeType::String,
  148         -
    "instance_owner_id",
         148  +
    "InstanceOwnerId",
  149    149   
    6,
  150    150   
)
  151    151   
.with_xml_name("instanceOwnerId");
  152    152   
static NETWORKINTERFACEATTACHMENT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  153    153   
    ::aws_smithy_schema::ShapeId::from_static(
  154    154   
        "com.amazonaws.ec2#NetworkInterfaceAttachment$Status",
  155    155   
        "com.amazonaws.ec2",
  156    156   
        "NetworkInterfaceAttachment",
  157    157   
    ),
  158    158   
    ::aws_smithy_schema::ShapeType::String,
  159         -
    "status",
         159  +
    "Status",
  160    160   
    7,
  161    161   
)
  162    162   
.with_xml_name("status");
  163    163   
static NETWORKINTERFACEATTACHMENT_MEMBER_ENA_SRD_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  164    164   
    ::aws_smithy_schema::ShapeId::from_static(
  165    165   
        "com.amazonaws.ec2#NetworkInterfaceAttachment$EnaSrdSpecification",
  166    166   
        "com.amazonaws.ec2",
  167    167   
        "NetworkInterfaceAttachment",
  168    168   
    ),
  169    169   
    ::aws_smithy_schema::ShapeType::Structure,
  170         -
    "ena_srd_specification",
         170  +
    "EnaSrdSpecification",
  171    171   
    8,
  172    172   
)
  173    173   
.with_xml_name("enaSrdSpecification");
  174    174   
static NETWORKINTERFACEATTACHMENT_MEMBER_ENA_QUEUE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  175    175   
    ::aws_smithy_schema::ShapeId::from_static(
  176    176   
        "com.amazonaws.ec2#NetworkInterfaceAttachment$EnaQueueCount",
  177    177   
        "com.amazonaws.ec2",
  178    178   
        "NetworkInterfaceAttachment",
  179    179   
    ),
  180    180   
    ::aws_smithy_schema::ShapeType::Integer,
  181         -
    "ena_queue_count",
         181  +
    "EnaQueueCount",
  182    182   
    9,
  183    183   
)
  184    184   
.with_xml_name("enaQueueCount");
  185    185   
static NETWORKINTERFACEATTACHMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  186    186   
    NETWORKINTERFACEATTACHMENT_SCHEMA_ID,
  187    187   
    ::aws_smithy_schema::ShapeType::Structure,
  188    188   
    &[
  189    189   
        &NETWORKINTERFACEATTACHMENT_MEMBER_ATTACH_TIME,
  190    190   
        &NETWORKINTERFACEATTACHMENT_MEMBER_ATTACHMENT_ID,
  191    191   
        &NETWORKINTERFACEATTACHMENT_MEMBER_DELETE_ON_TERMINATION,
@@ -216,216 +326,337 @@
  236    236   
            ser.write_struct(&NETWORKINTERFACEATTACHMENT_MEMBER_ENA_SRD_SPECIFICATION, val)?;
  237    237   
        }
  238    238   
        if let Some(ref val) = self.ena_queue_count {
  239    239   
            ser.write_integer(&NETWORKINTERFACEATTACHMENT_MEMBER_ENA_QUEUE_COUNT, *val)?;
  240    240   
        }
  241    241   
        Ok(())
  242    242   
    }
  243    243   
}
  244    244   
impl NetworkInterfaceAttachment {
  245    245   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  246         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  247         -
        deserializer: &mut D,
         246  +
    pub fn deserialize(
         247  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  248    248   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  249    249   
        #[allow(unused_variables, unused_mut)]
  250    250   
        let mut builder = Self::builder();
  251    251   
        #[allow(
  252    252   
            unused_variables,
  253    253   
            unreachable_code,
  254    254   
            clippy::single_match,
  255    255   
            clippy::match_single_binding,
  256    256   
            clippy::diverging_sub_expression
  257    257   
        )]
  258         -
        deserializer.read_struct(&NETWORKINTERFACEATTACHMENT_SCHEMA, (), |_, member, deser| {
         258  +
        deserializer.read_struct(&NETWORKINTERFACEATTACHMENT_SCHEMA, &mut |member, deser| {
  259    259   
            match member.member_index() {
  260    260   
                Some(0) => {
  261    261   
                    builder.attach_time = Some(deser.read_timestamp(member)?);
  262    262   
                }
  263    263   
                Some(1) => {
  264    264   
                    builder.attachment_id = Some(deser.read_string(member)?);
  265    265   
                }
  266    266   
                Some(2) => {
  267    267   
                    builder.delete_on_termination = Some(deser.read_boolean(member)?);
  268    268   
                }
  269    269   
                Some(3) => {
  270    270   
                    builder.device_index = Some(deser.read_integer(member)?);
  271    271   
                }
  272    272   
                Some(4) => {
  273    273   
                    builder.network_card_index = Some(deser.read_integer(member)?);
  274    274   
                }
  275    275   
                Some(5) => {
  276    276   
                    builder.instance_id = Some(deser.read_string(member)?);
  277    277   
                }
  278    278   
                Some(6) => {
  279    279   
                    builder.instance_owner_id = Some(deser.read_string(member)?);
  280    280   
                }
  281    281   
                Some(7) => {
  282    282   
                    builder.status = Some(crate::types::AttachmentStatus::from(deser.read_string(member)?.as_str()));
  283    283   
                }
  284    284   
                Some(8) => {
  285    285   
                    builder.ena_srd_specification = Some(crate::types::AttachmentEnaSrdSpecification::deserialize(deser)?);
  286    286   
                }
  287    287   
                Some(9) => {
  288    288   
                    builder.ena_queue_count = Some(deser.read_integer(member)?);
  289    289   
                }
  290    290   
                _ => {}
  291    291   
            }
  292    292   
            Ok(())
  293    293   
        })?;
  294    294   
        Ok(builder.build())
  295    295   
    }
  296    296   
}
         297  +
impl NetworkInterfaceAttachment {
         298  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         299  +
    pub fn deserialize_with_response(
         300  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         301  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         302  +
        _status: u16,
         303  +
        _body: &[u8],
         304  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         305  +
        Self::deserialize(deserializer)
         306  +
    }
         307  +
}
  297    308   
impl NetworkInterfaceAttachment {
  298    309   
    /// Creates a new builder-style object to manufacture [`NetworkInterfaceAttachment`](crate::types::NetworkInterfaceAttachment).
  299    310   
    pub fn builder() -> crate::types::builders::NetworkInterfaceAttachmentBuilder {
  300    311   
        crate::types::builders::NetworkInterfaceAttachmentBuilder::default()
  301    312   
    }
  302    313   
}
  303    314   
  304    315   
/// A builder for [`NetworkInterfaceAttachment`](crate::types::NetworkInterfaceAttachment).
  305    316   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  306    317   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_interface_attachment_changes.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_interface_count.rs

@@ -1,1 +128,139 @@
   21     21   
}
   22     22   
static NETWORKINTERFACECOUNT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NetworkInterfaceCount", "com.amazonaws.ec2", "NetworkInterfaceCount");
   24     24   
static NETWORKINTERFACECOUNT_MEMBER_MIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static(
   26     26   
        "com.amazonaws.ec2#NetworkInterfaceCount$Min",
   27     27   
        "com.amazonaws.ec2",
   28     28   
        "NetworkInterfaceCount",
   29     29   
    ),
   30     30   
    ::aws_smithy_schema::ShapeType::Integer,
   31         -
    "min",
          31  +
    "Min",
   32     32   
    0,
   33     33   
)
   34     34   
.with_xml_name("min");
   35     35   
static NETWORKINTERFACECOUNT_MEMBER_MAX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   36     36   
    ::aws_smithy_schema::ShapeId::from_static(
   37     37   
        "com.amazonaws.ec2#NetworkInterfaceCount$Max",
   38     38   
        "com.amazonaws.ec2",
   39     39   
        "NetworkInterfaceCount",
   40     40   
    ),
   41     41   
    ::aws_smithy_schema::ShapeType::Integer,
   42         -
    "max",
          42  +
    "Max",
   43     43   
    1,
   44     44   
)
   45     45   
.with_xml_name("max");
   46     46   
static NETWORKINTERFACECOUNT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   47     47   
    NETWORKINTERFACECOUNT_SCHEMA_ID,
   48     48   
    ::aws_smithy_schema::ShapeType::Structure,
   49     49   
    &[&NETWORKINTERFACECOUNT_MEMBER_MIN, &NETWORKINTERFACECOUNT_MEMBER_MAX],
   50     50   
);
   51     51   
impl NetworkInterfaceCount {
   52     52   
    /// The schema for this shape.
   53     53   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NETWORKINTERFACECOUNT_SCHEMA;
   54     54   
}
   55     55   
impl ::aws_smithy_schema::serde::SerializableStruct for NetworkInterfaceCount {
   56     56   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   57     57   
    fn serialize_members(
   58     58   
        &self,
   59     59   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   60     60   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   61     61   
        if let Some(ref val) = self.min {
   62     62   
            ser.write_integer(&NETWORKINTERFACECOUNT_MEMBER_MIN, *val)?;
   63     63   
        }
   64     64   
        if let Some(ref val) = self.max {
   65     65   
            ser.write_integer(&NETWORKINTERFACECOUNT_MEMBER_MAX, *val)?;
   66     66   
        }
   67     67   
        Ok(())
   68     68   
    }
   69     69   
}
   70     70   
impl NetworkInterfaceCount {
   71     71   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   72         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   73         -
        deserializer: &mut D,
          72  +
    pub fn deserialize(
          73  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   74     74   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   75     75   
        #[allow(unused_variables, unused_mut)]
   76     76   
        let mut builder = Self::builder();
   77     77   
        #[allow(
   78     78   
            unused_variables,
   79     79   
            unreachable_code,
   80     80   
            clippy::single_match,
   81     81   
            clippy::match_single_binding,
   82     82   
            clippy::diverging_sub_expression
   83     83   
        )]
   84         -
        deserializer.read_struct(&NETWORKINTERFACECOUNT_SCHEMA, (), |_, member, deser| {
          84  +
        deserializer.read_struct(&NETWORKINTERFACECOUNT_SCHEMA, &mut |member, deser| {
   85     85   
            match member.member_index() {
   86     86   
                Some(0) => {
   87     87   
                    builder.min = Some(deser.read_integer(member)?);
   88     88   
                }
   89     89   
                Some(1) => {
   90     90   
                    builder.max = Some(deser.read_integer(member)?);
   91     91   
                }
   92     92   
                _ => {}
   93     93   
            }
   94     94   
            Ok(())
   95     95   
        })?;
   96     96   
        Ok(builder.build())
   97     97   
    }
   98     98   
}
          99  +
impl NetworkInterfaceCount {
         100  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         101  +
    pub fn deserialize_with_response(
         102  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         103  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         104  +
        _status: u16,
         105  +
        _body: &[u8],
         106  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         107  +
        Self::deserialize(deserializer)
         108  +
    }
         109  +
}
   99    110   
impl NetworkInterfaceCount {
  100    111   
    /// Creates a new builder-style object to manufacture [`NetworkInterfaceCount`](crate::types::NetworkInterfaceCount).
  101    112   
    pub fn builder() -> crate::types::builders::NetworkInterfaceCountBuilder {
  102    113   
        crate::types::builders::NetworkInterfaceCountBuilder::default()
  103    114   
    }
  104    115   
}
  105    116   
  106    117   
/// A builder for [`NetworkInterfaceCount`](crate::types::NetworkInterfaceCount).
  107    118   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  108    119   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_interface_count_request.rs

@@ -4,4 +129,140 @@
   24     24   
    "com.amazonaws.ec2",
   25     25   
    "NetworkInterfaceCountRequest",
   26     26   
);
   27     27   
static NETWORKINTERFACECOUNTREQUEST_MEMBER_MIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.ec2#NetworkInterfaceCountRequest$Min",
   30     30   
        "com.amazonaws.ec2",
   31     31   
        "NetworkInterfaceCountRequest",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::Integer,
   34         -
    "min",
          34  +
    "Min",
   35     35   
    0,
   36     36   
);
   37     37   
static NETWORKINTERFACECOUNTREQUEST_MEMBER_MAX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.ec2#NetworkInterfaceCountRequest$Max",
   40     40   
        "com.amazonaws.ec2",
   41     41   
        "NetworkInterfaceCountRequest",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Integer,
   44         -
    "max",
          44  +
    "Max",
   45     45   
    1,
   46     46   
);
   47     47   
static NETWORKINTERFACECOUNTREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    NETWORKINTERFACECOUNTREQUEST_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[&NETWORKINTERFACECOUNTREQUEST_MEMBER_MIN, &NETWORKINTERFACECOUNTREQUEST_MEMBER_MAX],
   51     51   
);
   52     52   
impl NetworkInterfaceCountRequest {
   53     53   
    /// The schema for this shape.
   54     54   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NETWORKINTERFACECOUNTREQUEST_SCHEMA;
   55     55   
}
   56     56   
impl ::aws_smithy_schema::serde::SerializableStruct for NetworkInterfaceCountRequest {
   57     57   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   58     58   
    fn serialize_members(
   59     59   
        &self,
   60     60   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   61     61   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   62     62   
        if let Some(ref val) = self.min {
   63     63   
            ser.write_integer(&NETWORKINTERFACECOUNTREQUEST_MEMBER_MIN, *val)?;
   64     64   
        }
   65     65   
        if let Some(ref val) = self.max {
   66     66   
            ser.write_integer(&NETWORKINTERFACECOUNTREQUEST_MEMBER_MAX, *val)?;
   67     67   
        }
   68     68   
        Ok(())
   69     69   
    }
   70     70   
}
   71     71   
impl NetworkInterfaceCountRequest {
   72     72   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   73         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   74         -
        deserializer: &mut D,
          73  +
    pub fn deserialize(
          74  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   75     75   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   76     76   
        #[allow(unused_variables, unused_mut)]
   77     77   
        let mut builder = Self::builder();
   78     78   
        #[allow(
   79     79   
            unused_variables,
   80     80   
            unreachable_code,
   81     81   
            clippy::single_match,
   82     82   
            clippy::match_single_binding,
   83     83   
            clippy::diverging_sub_expression
   84     84   
        )]
   85         -
        deserializer.read_struct(&NETWORKINTERFACECOUNTREQUEST_SCHEMA, (), |_, member, deser| {
          85  +
        deserializer.read_struct(&NETWORKINTERFACECOUNTREQUEST_SCHEMA, &mut |member, deser| {
   86     86   
            match member.member_index() {
   87     87   
                Some(0) => {
   88     88   
                    builder.min = Some(deser.read_integer(member)?);
   89     89   
                }
   90     90   
                Some(1) => {
   91     91   
                    builder.max = Some(deser.read_integer(member)?);
   92     92   
                }
   93     93   
                _ => {}
   94     94   
            }
   95     95   
            Ok(())
   96     96   
        })?;
   97     97   
        Ok(builder.build())
   98     98   
    }
   99     99   
}
         100  +
impl NetworkInterfaceCountRequest {
         101  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         102  +
    pub fn deserialize_with_response(
         103  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         104  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         105  +
        _status: u16,
         106  +
        _body: &[u8],
         107  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         108  +
        Self::deserialize(deserializer)
         109  +
    }
         110  +
}
  100    111   
impl NetworkInterfaceCountRequest {
  101    112   
    /// Creates a new builder-style object to manufacture [`NetworkInterfaceCountRequest`](crate::types::NetworkInterfaceCountRequest).
  102    113   
    pub fn builder() -> crate::types::builders::NetworkInterfaceCountRequestBuilder {
  103    114   
        crate::types::builders::NetworkInterfaceCountRequestBuilder::default()
  104    115   
    }
  105    116   
}
  106    117   
  107    118   
/// A builder for [`NetworkInterfaceCountRequest`](crate::types::NetworkInterfaceCountRequest).
  108    119   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  109    120   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_interface_ipv6_address.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_network_interface_permission.rs

@@ -28,28 +230,241 @@
   48     48   
    "com.amazonaws.ec2",
   49     49   
    "NetworkInterfacePermission",
   50     50   
);
   51     51   
static NETWORKINTERFACEPERMISSION_MEMBER_NETWORK_INTERFACE_PERMISSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.ec2#NetworkInterfacePermission$NetworkInterfacePermissionId",
   54     54   
        "com.amazonaws.ec2",
   55     55   
        "NetworkInterfacePermission",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::String,
   58         -
    "network_interface_permission_id",
          58  +
    "NetworkInterfacePermissionId",
   59     59   
    0,
   60     60   
)
   61     61   
.with_xml_name("networkInterfacePermissionId");
   62     62   
static NETWORKINTERFACEPERMISSION_MEMBER_NETWORK_INTERFACE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.ec2#NetworkInterfacePermission$NetworkInterfaceId",
   65     65   
        "com.amazonaws.ec2",
   66     66   
        "NetworkInterfacePermission",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "network_interface_id",
          69  +
    "NetworkInterfaceId",
   70     70   
    1,
   71     71   
)
   72     72   
.with_xml_name("networkInterfaceId");
   73     73   
static NETWORKINTERFACEPERMISSION_MEMBER_AWS_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.ec2#NetworkInterfacePermission$AwsAccountId",
   76     76   
        "com.amazonaws.ec2",
   77     77   
        "NetworkInterfacePermission",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "aws_account_id",
          80  +
    "AwsAccountId",
   81     81   
    2,
   82     82   
)
   83     83   
.with_xml_name("awsAccountId");
   84     84   
static NETWORKINTERFACEPERMISSION_MEMBER_AWS_SERVICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "com.amazonaws.ec2#NetworkInterfacePermission$AwsService",
   87     87   
        "com.amazonaws.ec2",
   88     88   
        "NetworkInterfacePermission",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::String,
   91         -
    "aws_service",
          91  +
    "AwsService",
   92     92   
    3,
   93     93   
)
   94     94   
.with_xml_name("awsService");
   95     95   
static NETWORKINTERFACEPERMISSION_MEMBER_PERMISSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.ec2#NetworkInterfacePermission$Permission",
   98     98   
        "com.amazonaws.ec2",
   99     99   
        "NetworkInterfacePermission",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::String,
  102         -
    "permission",
         102  +
    "Permission",
  103    103   
    4,
  104    104   
)
  105    105   
.with_xml_name("permission");
  106    106   
static NETWORKINTERFACEPERMISSION_MEMBER_PERMISSION_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.ec2#NetworkInterfacePermission$PermissionState",
  109    109   
        "com.amazonaws.ec2",
  110    110   
        "NetworkInterfacePermission",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::Structure,
  113         -
    "permission_state",
         113  +
    "PermissionState",
  114    114   
    5,
  115    115   
)
  116    116   
.with_xml_name("permissionState");
  117    117   
static NETWORKINTERFACEPERMISSION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  118    118   
    NETWORKINTERFACEPERMISSION_SCHEMA_ID,
  119    119   
    ::aws_smithy_schema::ShapeType::Structure,
  120    120   
    &[
  121    121   
        &NETWORKINTERFACEPERMISSION_MEMBER_NETWORK_INTERFACE_PERMISSION_ID,
  122    122   
        &NETWORKINTERFACEPERMISSION_MEMBER_NETWORK_INTERFACE_ID,
  123    123   
        &NETWORKINTERFACEPERMISSION_MEMBER_AWS_ACCOUNT_ID,
  124    124   
        &NETWORKINTERFACEPERMISSION_MEMBER_AWS_SERVICE,
  125    125   
        &NETWORKINTERFACEPERMISSION_MEMBER_PERMISSION,
  126    126   
        &NETWORKINTERFACEPERMISSION_MEMBER_PERMISSION_STATE,
  127    127   
    ],
  128    128   
);
  129    129   
impl NetworkInterfacePermission {
  130    130   
    /// The schema for this shape.
  131    131   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NETWORKINTERFACEPERMISSION_SCHEMA;
  132    132   
}
  133    133   
impl ::aws_smithy_schema::serde::SerializableStruct for NetworkInterfacePermission {
  134    134   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  135    135   
    fn serialize_members(
  136    136   
        &self,
  137    137   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  138    138   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  139    139   
        if let Some(ref val) = self.network_interface_permission_id {
  140    140   
            ser.write_string(&NETWORKINTERFACEPERMISSION_MEMBER_NETWORK_INTERFACE_PERMISSION_ID, val)?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.network_interface_id {
  143    143   
            ser.write_string(&NETWORKINTERFACEPERMISSION_MEMBER_NETWORK_INTERFACE_ID, val)?;
  144    144   
        }
  145    145   
        if let Some(ref val) = self.aws_account_id {
  146    146   
            ser.write_string(&NETWORKINTERFACEPERMISSION_MEMBER_AWS_ACCOUNT_ID, val)?;
  147    147   
        }
  148    148   
        if let Some(ref val) = self.aws_service {
  149    149   
            ser.write_string(&NETWORKINTERFACEPERMISSION_MEMBER_AWS_SERVICE, val)?;
  150    150   
        }
  151    151   
        if let Some(ref val) = self.permission {
  152    152   
            ser.write_string(&NETWORKINTERFACEPERMISSION_MEMBER_PERMISSION, val.as_str())?;
  153    153   
        }
  154    154   
        if let Some(ref val) = self.permission_state {
  155    155   
            ser.write_struct(&NETWORKINTERFACEPERMISSION_MEMBER_PERMISSION_STATE, val)?;
  156    156   
        }
  157    157   
        Ok(())
  158    158   
    }
  159    159   
}
  160    160   
impl NetworkInterfacePermission {
  161    161   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  162         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  163         -
        deserializer: &mut D,
         162  +
    pub fn deserialize(
         163  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  164    164   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  165    165   
        #[allow(unused_variables, unused_mut)]
  166    166   
        let mut builder = Self::builder();
  167    167   
        #[allow(
  168    168   
            unused_variables,
  169    169   
            unreachable_code,
  170    170   
            clippy::single_match,
  171    171   
            clippy::match_single_binding,
  172    172   
            clippy::diverging_sub_expression
  173    173   
        )]
  174         -
        deserializer.read_struct(&NETWORKINTERFACEPERMISSION_SCHEMA, (), |_, member, deser| {
         174  +
        deserializer.read_struct(&NETWORKINTERFACEPERMISSION_SCHEMA, &mut |member, deser| {
  175    175   
            match member.member_index() {
  176    176   
                Some(0) => {
  177    177   
                    builder.network_interface_permission_id = Some(deser.read_string(member)?);
  178    178   
                }
  179    179   
                Some(1) => {
  180    180   
                    builder.network_interface_id = Some(deser.read_string(member)?);
  181    181   
                }
  182    182   
                Some(2) => {
  183    183   
                    builder.aws_account_id = Some(deser.read_string(member)?);
  184    184   
                }
  185    185   
                Some(3) => {
  186    186   
                    builder.aws_service = Some(deser.read_string(member)?);
  187    187   
                }
  188    188   
                Some(4) => {
  189    189   
                    builder.permission = Some(crate::types::InterfacePermissionType::from(deser.read_string(member)?.as_str()));
  190    190   
                }
  191    191   
                Some(5) => {
  192    192   
                    builder.permission_state = Some(crate::types::NetworkInterfacePermissionState::deserialize(deser)?);
  193    193   
                }
  194    194   
                _ => {}
  195    195   
            }
  196    196   
            Ok(())
  197    197   
        })?;
  198    198   
        Ok(builder.build())
  199    199   
    }
  200    200   
}
         201  +
impl NetworkInterfacePermission {
         202  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         203  +
    pub fn deserialize_with_response(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         205  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         206  +
        _status: u16,
         207  +
        _body: &[u8],
         208  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         209  +
        Self::deserialize(deserializer)
         210  +
    }
         211  +
}
  201    212   
impl NetworkInterfacePermission {
  202    213   
    /// Creates a new builder-style object to manufacture [`NetworkInterfacePermission`](crate::types::NetworkInterfacePermission).
  203    214   
    pub fn builder() -> crate::types::builders::NetworkInterfacePermissionBuilder {
  204    215   
        crate::types::builders::NetworkInterfacePermissionBuilder::default()
  205    216   
    }
  206    217   
}
  207    218   
  208    219   
/// A builder for [`NetworkInterfacePermission`](crate::types::NetworkInterfacePermission).
  209    220   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  210    221   
#[non_exhaustive]