AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c

Files changed:

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

@@ -25,25 +219,230 @@
   45     45   
}
   46     46   
static EBSOPTIMIZEDINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#EbsOptimizedInfo", "com.amazonaws.ec2", "EbsOptimizedInfo");
   48     48   
static EBSOPTIMIZEDINFO_MEMBER_BASELINE_BANDWIDTH_IN_MBPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static(
   50     50   
        "com.amazonaws.ec2#EbsOptimizedInfo$BaselineBandwidthInMbps",
   51     51   
        "com.amazonaws.ec2",
   52     52   
        "EbsOptimizedInfo",
   53     53   
    ),
   54     54   
    ::aws_smithy_schema::ShapeType::Integer,
   55         -
    "baseline_bandwidth_in_mbps",
          55  +
    "BaselineBandwidthInMbps",
   56     56   
    0,
   57     57   
)
   58     58   
.with_xml_name("baselineBandwidthInMbps");
   59     59   
static EBSOPTIMIZEDINFO_MEMBER_BASELINE_THROUGHPUT_IN_M_BPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.ec2#EbsOptimizedInfo$BaselineThroughputInMBps",
   62     62   
        "com.amazonaws.ec2",
   63     63   
        "EbsOptimizedInfo",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::Double,
   66         -
    "baseline_throughput_in_m_bps",
          66  +
    "BaselineThroughputInMBps",
   67     67   
    1,
   68     68   
)
   69     69   
.with_xml_name("baselineThroughputInMBps");
   70     70   
static EBSOPTIMIZEDINFO_MEMBER_BASELINE_IOPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#EbsOptimizedInfo$BaselineIops", "com.amazonaws.ec2", "EbsOptimizedInfo"),
   72     72   
    ::aws_smithy_schema::ShapeType::Integer,
   73         -
    "baseline_iops",
          73  +
    "BaselineIops",
   74     74   
    2,
   75     75   
)
   76     76   
.with_xml_name("baselineIops");
   77     77   
static EBSOPTIMIZEDINFO_MEMBER_MAXIMUM_BANDWIDTH_IN_MBPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.ec2#EbsOptimizedInfo$MaximumBandwidthInMbps",
   80     80   
        "com.amazonaws.ec2",
   81     81   
        "EbsOptimizedInfo",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::Integer,
   84         -
    "maximum_bandwidth_in_mbps",
          84  +
    "MaximumBandwidthInMbps",
   85     85   
    3,
   86     86   
)
   87     87   
.with_xml_name("maximumBandwidthInMbps");
   88     88   
static EBSOPTIMIZEDINFO_MEMBER_MAXIMUM_THROUGHPUT_IN_M_BPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.ec2#EbsOptimizedInfo$MaximumThroughputInMBps",
   91     91   
        "com.amazonaws.ec2",
   92     92   
        "EbsOptimizedInfo",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::Double,
   95         -
    "maximum_throughput_in_m_bps",
          95  +
    "MaximumThroughputInMBps",
   96     96   
    4,
   97     97   
)
   98     98   
.with_xml_name("maximumThroughputInMBps");
   99     99   
static EBSOPTIMIZEDINFO_MEMBER_MAXIMUM_IOPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#EbsOptimizedInfo$MaximumIops", "com.amazonaws.ec2", "EbsOptimizedInfo"),
  101    101   
    ::aws_smithy_schema::ShapeType::Integer,
  102         -
    "maximum_iops",
         102  +
    "MaximumIops",
  103    103   
    5,
  104    104   
)
  105    105   
.with_xml_name("maximumIops");
  106    106   
static EBSOPTIMIZEDINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  107    107   
    EBSOPTIMIZEDINFO_SCHEMA_ID,
  108    108   
    ::aws_smithy_schema::ShapeType::Structure,
  109    109   
    &[
  110    110   
        &EBSOPTIMIZEDINFO_MEMBER_BASELINE_BANDWIDTH_IN_MBPS,
  111    111   
        &EBSOPTIMIZEDINFO_MEMBER_BASELINE_THROUGHPUT_IN_M_BPS,
  112    112   
        &EBSOPTIMIZEDINFO_MEMBER_BASELINE_IOPS,
  113    113   
        &EBSOPTIMIZEDINFO_MEMBER_MAXIMUM_BANDWIDTH_IN_MBPS,
  114    114   
        &EBSOPTIMIZEDINFO_MEMBER_MAXIMUM_THROUGHPUT_IN_M_BPS,
  115    115   
        &EBSOPTIMIZEDINFO_MEMBER_MAXIMUM_IOPS,
  116    116   
    ],
  117    117   
);
  118    118   
impl EbsOptimizedInfo {
  119    119   
    /// The schema for this shape.
  120    120   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EBSOPTIMIZEDINFO_SCHEMA;
  121    121   
}
  122    122   
impl ::aws_smithy_schema::serde::SerializableStruct for EbsOptimizedInfo {
  123    123   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  124    124   
    fn serialize_members(
  125    125   
        &self,
  126    126   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  127    127   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  128    128   
        if let Some(ref val) = self.baseline_bandwidth_in_mbps {
  129    129   
            ser.write_integer(&EBSOPTIMIZEDINFO_MEMBER_BASELINE_BANDWIDTH_IN_MBPS, *val)?;
  130    130   
        }
  131    131   
        if let Some(ref val) = self.baseline_throughput_in_m_bps {
  132    132   
            ser.write_double(&EBSOPTIMIZEDINFO_MEMBER_BASELINE_THROUGHPUT_IN_M_BPS, *val)?;
  133    133   
        }
  134    134   
        if let Some(ref val) = self.baseline_iops {
  135    135   
            ser.write_integer(&EBSOPTIMIZEDINFO_MEMBER_BASELINE_IOPS, *val)?;
  136    136   
        }
  137    137   
        if let Some(ref val) = self.maximum_bandwidth_in_mbps {
  138    138   
            ser.write_integer(&EBSOPTIMIZEDINFO_MEMBER_MAXIMUM_BANDWIDTH_IN_MBPS, *val)?;
  139    139   
        }
  140    140   
        if let Some(ref val) = self.maximum_throughput_in_m_bps {
  141    141   
            ser.write_double(&EBSOPTIMIZEDINFO_MEMBER_MAXIMUM_THROUGHPUT_IN_M_BPS, *val)?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.maximum_iops {
  144    144   
            ser.write_integer(&EBSOPTIMIZEDINFO_MEMBER_MAXIMUM_IOPS, *val)?;
  145    145   
        }
  146    146   
        Ok(())
  147    147   
    }
  148    148   
}
  149    149   
impl EbsOptimizedInfo {
  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(&EBSOPTIMIZEDINFO_SCHEMA, (), |_, member, deser| {
         163  +
        deserializer.read_struct(&EBSOPTIMIZEDINFO_SCHEMA, &mut |member, deser| {
  164    164   
            match member.member_index() {
  165    165   
                Some(0) => {
  166    166   
                    builder.baseline_bandwidth_in_mbps = Some(deser.read_integer(member)?);
  167    167   
                }
  168    168   
                Some(1) => {
  169    169   
                    builder.baseline_throughput_in_m_bps = Some(deser.read_double(member)?);
  170    170   
                }
  171    171   
                Some(2) => {
  172    172   
                    builder.baseline_iops = Some(deser.read_integer(member)?);
  173    173   
                }
  174    174   
                Some(3) => {
  175    175   
                    builder.maximum_bandwidth_in_mbps = Some(deser.read_integer(member)?);
  176    176   
                }
  177    177   
                Some(4) => {
  178    178   
                    builder.maximum_throughput_in_m_bps = Some(deser.read_double(member)?);
  179    179   
                }
  180    180   
                Some(5) => {
  181    181   
                    builder.maximum_iops = Some(deser.read_integer(member)?);
  182    182   
                }
  183    183   
                _ => {}
  184    184   
            }
  185    185   
            Ok(())
  186    186   
        })?;
  187    187   
        Ok(builder.build())
  188    188   
    }
  189    189   
}
         190  +
impl EbsOptimizedInfo {
         191  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         192  +
    pub fn deserialize_with_response(
         193  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         194  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         195  +
        _status: u16,
         196  +
        _body: &[u8],
         197  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         198  +
        Self::deserialize(deserializer)
         199  +
    }
         200  +
}
  190    201   
impl EbsOptimizedInfo {
  191    202   
    /// Creates a new builder-style object to manufacture [`EbsOptimizedInfo`](crate::types::EbsOptimizedInfo).
  192    203   
    pub fn builder() -> crate::types::builders::EbsOptimizedInfoBuilder {
  193    204   
        crate::types::builders::EbsOptimizedInfoBuilder::default()
  194    205   
    }
  195    206   
}
  196    207   
  197    208   
/// A builder for [`EbsOptimizedInfo`](crate::types::EbsOptimizedInfo).
  198    209   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  199    210   
#[non_exhaustive]

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

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

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

@@ -1,1 +140,148 @@
   19     19   
    /// <p>The current status.</p>
   20     20   
    pub fn status(&self) -> ::std::option::Option<&crate::types::SummaryStatus> {
   21     21   
        self.status.as_ref()
   22     22   
    }
   23     23   
}
   24     24   
static EBSSTATUSSUMMARY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#EbsStatusSummary", "com.amazonaws.ec2", "EbsStatusSummary");
   26     26   
static EBSSTATUSSUMMARY_MEMBER_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#EbsStatusSummary$Details", "com.amazonaws.ec2", "EbsStatusSummary"),
   28     28   
    ::aws_smithy_schema::ShapeType::List,
   29         -
    "details",
          29  +
    "Details",
   30     30   
    0,
   31     31   
)
   32     32   
.with_xml_name("details");
   33     33   
static EBSSTATUSSUMMARY_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#EbsStatusSummary$Status", "com.amazonaws.ec2", "EbsStatusSummary"),
   35     35   
    ::aws_smithy_schema::ShapeType::String,
   36         -
    "status",
          36  +
    "Status",
   37     37   
    1,
   38     38   
)
   39     39   
.with_xml_name("status");
   40     40   
static EBSSTATUSSUMMARY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   41     41   
    EBSSTATUSSUMMARY_SCHEMA_ID,
   42     42   
    ::aws_smithy_schema::ShapeType::Structure,
   43     43   
    &[&EBSSTATUSSUMMARY_MEMBER_DETAILS, &EBSSTATUSSUMMARY_MEMBER_STATUS],
   44     44   
);
   45     45   
impl EbsStatusSummary {
   46     46   
    /// The schema for this shape.
   47     47   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EBSSTATUSSUMMARY_SCHEMA;
   48     48   
}
   49     49   
impl ::aws_smithy_schema::serde::SerializableStruct for EbsStatusSummary {
   50     50   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   51     51   
    fn serialize_members(
   52     52   
        &self,
   53     53   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   54     54   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   55     55   
        if let Some(ref val) = self.details {
   56     56   
            ser.write_list(
   57     57   
                &EBSSTATUSSUMMARY_MEMBER_DETAILS,
   58     58   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   59     59   
                    for item in val {
   60     60   
                        ser.write_struct(crate::types::EbsStatusDetails::SCHEMA, item)?;
   61     61   
                    }
   62     62   
                    Ok(())
   63     63   
                },
   64     64   
            )?;
   65     65   
        }
   66     66   
        if let Some(ref val) = self.status {
   67     67   
            ser.write_string(&EBSSTATUSSUMMARY_MEMBER_STATUS, val.as_str())?;
   68     68   
        }
   69     69   
        Ok(())
   70     70   
    }
   71     71   
}
   72     72   
impl EbsStatusSummary {
   73     73   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   74         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   75         -
        deserializer: &mut D,
          74  +
    pub fn deserialize(
          75  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   76     76   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   77     77   
        #[allow(unused_variables, unused_mut)]
   78     78   
        let mut builder = Self::builder();
   79     79   
        #[allow(
   80     80   
            unused_variables,
   81     81   
            unreachable_code,
   82     82   
            clippy::single_match,
   83     83   
            clippy::match_single_binding,
   84     84   
            clippy::diverging_sub_expression
   85     85   
        )]
   86         -
        deserializer.read_struct(&EBSSTATUSSUMMARY_SCHEMA, (), |_, member, deser| {
          86  +
        deserializer.read_struct(&EBSSTATUSSUMMARY_SCHEMA, &mut |member, deser| {
   87     87   
            match member.member_index() {
   88     88   
                Some(0) => {
   89     89   
                    builder.details = Some({
   90         -
                        let container = if let Some(cap) = deser.container_size() {
   91         -
                            Vec::with_capacity(cap)
   92         -
                        } else {
   93         -
                            Vec::new()
   94         -
                        };
   95         -
                        deser.read_list(member, container, |mut list, deser| {
   96         -
                            list.push(crate::types::EbsStatusDetails::deserialize(deser)?);
   97         -
                            Ok(list)
   98         -
                        })?
          90  +
                        let mut container = Vec::new();
          91  +
                        deser.read_list(member, &mut |deser| {
          92  +
                            container.push(crate::types::EbsStatusDetails::deserialize(deser)?);
          93  +
                            Ok(())
          94  +
                        })?;
          95  +
                        container
   99     96   
                    });
  100     97   
                }
  101     98   
                Some(1) => {
  102     99   
                    builder.status = Some(crate::types::SummaryStatus::from(deser.read_string(member)?.as_str()));
  103    100   
                }
  104    101   
                _ => {}
  105    102   
            }
  106    103   
            Ok(())
  107    104   
        })?;
  108    105   
        Ok(builder.build())
  109    106   
    }
  110    107   
}
         108  +
impl EbsStatusSummary {
         109  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         110  +
    pub fn deserialize_with_response(
         111  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         112  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         113  +
        _status: u16,
         114  +
        _body: &[u8],
         115  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         116  +
        Self::deserialize(deserializer)
         117  +
    }
         118  +
}
  111    119   
impl EbsStatusSummary {
  112    120   
    /// Creates a new builder-style object to manufacture [`EbsStatusSummary`](crate::types::EbsStatusSummary).
  113    121   
    pub fn builder() -> crate::types::builders::EbsStatusSummaryBuilder {
  114    122   
        crate::types::builders::EbsStatusSummaryBuilder::default()
  115    123   
    }
  116    124   
}
  117    125   
  118    126   
/// A builder for [`EbsStatusSummary`](crate::types::EbsStatusSummary).
  119    127   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  120    128   
#[non_exhaustive]

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

@@ -114,114 +350,350 @@
  134    134   
    "com.amazonaws.ec2",
  135    135   
    "Ec2InstanceConnectEndpoint",
  136    136   
);
  137    137   
static EC2INSTANCECONNECTENDPOINT_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static(
  139    139   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$OwnerId",
  140    140   
        "com.amazonaws.ec2",
  141    141   
        "Ec2InstanceConnectEndpoint",
  142    142   
    ),
  143    143   
    ::aws_smithy_schema::ShapeType::String,
  144         -
    "owner_id",
         144  +
    "OwnerId",
  145    145   
    0,
  146    146   
)
  147    147   
.with_xml_name("ownerId");
  148    148   
static EC2INSTANCECONNECTENDPOINT_MEMBER_INSTANCE_CONNECT_ENDPOINT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  149    149   
    ::aws_smithy_schema::ShapeId::from_static(
  150    150   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$InstanceConnectEndpointId",
  151    151   
        "com.amazonaws.ec2",
  152    152   
        "Ec2InstanceConnectEndpoint",
  153    153   
    ),
  154    154   
    ::aws_smithy_schema::ShapeType::String,
  155         -
    "instance_connect_endpoint_id",
         155  +
    "InstanceConnectEndpointId",
  156    156   
    1,
  157    157   
)
  158    158   
.with_xml_name("instanceConnectEndpointId");
  159    159   
static EC2INSTANCECONNECTENDPOINT_MEMBER_INSTANCE_CONNECT_ENDPOINT_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  160    160   
    ::aws_smithy_schema::ShapeId::from_static(
  161    161   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$InstanceConnectEndpointArn",
  162    162   
        "com.amazonaws.ec2",
  163    163   
        "Ec2InstanceConnectEndpoint",
  164    164   
    ),
  165    165   
    ::aws_smithy_schema::ShapeType::String,
  166         -
    "instance_connect_endpoint_arn",
         166  +
    "InstanceConnectEndpointArn",
  167    167   
    2,
  168    168   
)
  169    169   
.with_xml_name("instanceConnectEndpointArn");
  170    170   
static EC2INSTANCECONNECTENDPOINT_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  171    171   
    ::aws_smithy_schema::ShapeId::from_static(
  172    172   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$State",
  173    173   
        "com.amazonaws.ec2",
  174    174   
        "Ec2InstanceConnectEndpoint",
  175    175   
    ),
  176    176   
    ::aws_smithy_schema::ShapeType::String,
  177         -
    "state",
         177  +
    "State",
  178    178   
    3,
  179    179   
)
  180    180   
.with_xml_name("state");
  181    181   
static EC2INSTANCECONNECTENDPOINT_MEMBER_STATE_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  182    182   
    ::aws_smithy_schema::ShapeId::from_static(
  183    183   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$StateMessage",
  184    184   
        "com.amazonaws.ec2",
  185    185   
        "Ec2InstanceConnectEndpoint",
  186    186   
    ),
  187    187   
    ::aws_smithy_schema::ShapeType::String,
  188         -
    "state_message",
         188  +
    "StateMessage",
  189    189   
    4,
  190    190   
)
  191    191   
.with_xml_name("stateMessage");
  192    192   
static EC2INSTANCECONNECTENDPOINT_MEMBER_DNS_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  193    193   
    ::aws_smithy_schema::ShapeId::from_static(
  194    194   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$DnsName",
  195    195   
        "com.amazonaws.ec2",
  196    196   
        "Ec2InstanceConnectEndpoint",
  197    197   
    ),
  198    198   
    ::aws_smithy_schema::ShapeType::String,
  199         -
    "dns_name",
         199  +
    "DnsName",
  200    200   
    5,
  201    201   
)
  202    202   
.with_xml_name("dnsName");
  203    203   
static EC2INSTANCECONNECTENDPOINT_MEMBER_FIPS_DNS_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  204    204   
    ::aws_smithy_schema::ShapeId::from_static(
  205    205   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$FipsDnsName",
  206    206   
        "com.amazonaws.ec2",
  207    207   
        "Ec2InstanceConnectEndpoint",
  208    208   
    ),
  209    209   
    ::aws_smithy_schema::ShapeType::String,
  210         -
    "fips_dns_name",
         210  +
    "FipsDnsName",
  211    211   
    6,
  212    212   
)
  213    213   
.with_xml_name("fipsDnsName");
  214    214   
static EC2INSTANCECONNECTENDPOINT_MEMBER_NETWORK_INTERFACE_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  215    215   
    ::aws_smithy_schema::ShapeId::from_static(
  216    216   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$NetworkInterfaceIds",
  217    217   
        "com.amazonaws.ec2",
  218    218   
        "Ec2InstanceConnectEndpoint",
  219    219   
    ),
  220    220   
    ::aws_smithy_schema::ShapeType::List,
  221         -
    "network_interface_ids",
         221  +
    "NetworkInterfaceIds",
  222    222   
    7,
  223    223   
)
  224    224   
.with_xml_name("networkInterfaceIdSet");
  225    225   
static EC2INSTANCECONNECTENDPOINT_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  226    226   
    ::aws_smithy_schema::ShapeId::from_static(
  227    227   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$VpcId",
  228    228   
        "com.amazonaws.ec2",
  229    229   
        "Ec2InstanceConnectEndpoint",
  230    230   
    ),
  231    231   
    ::aws_smithy_schema::ShapeType::String,
  232         -
    "vpc_id",
         232  +
    "VpcId",
  233    233   
    8,
  234    234   
)
  235    235   
.with_xml_name("vpcId");
  236    236   
static EC2INSTANCECONNECTENDPOINT_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  237    237   
    ::aws_smithy_schema::ShapeId::from_static(
  238    238   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$AvailabilityZone",
  239    239   
        "com.amazonaws.ec2",
  240    240   
        "Ec2InstanceConnectEndpoint",
  241    241   
    ),
  242    242   
    ::aws_smithy_schema::ShapeType::String,
  243         -
    "availability_zone",
         243  +
    "AvailabilityZone",
  244    244   
    9,
  245    245   
)
  246    246   
.with_xml_name("availabilityZone");
  247    247   
static EC2INSTANCECONNECTENDPOINT_MEMBER_CREATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  248    248   
    ::aws_smithy_schema::ShapeId::from_static(
  249    249   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$CreatedAt",
  250    250   
        "com.amazonaws.ec2",
  251    251   
        "Ec2InstanceConnectEndpoint",
  252    252   
    ),
  253    253   
    ::aws_smithy_schema::ShapeType::Timestamp,
  254         -
    "created_at",
         254  +
    "CreatedAt",
  255    255   
    10,
  256    256   
)
  257    257   
.with_xml_name("createdAt");
  258    258   
static EC2INSTANCECONNECTENDPOINT_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  259    259   
    ::aws_smithy_schema::ShapeId::from_static(
  260    260   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$SubnetId",
  261    261   
        "com.amazonaws.ec2",
  262    262   
        "Ec2InstanceConnectEndpoint",
  263    263   
    ),
  264    264   
    ::aws_smithy_schema::ShapeType::String,
  265         -
    "subnet_id",
         265  +
    "SubnetId",
  266    266   
    11,
  267    267   
)
  268    268   
.with_xml_name("subnetId");
  269    269   
static EC2INSTANCECONNECTENDPOINT_MEMBER_PRESERVE_CLIENT_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  270    270   
    ::aws_smithy_schema::ShapeId::from_static(
  271    271   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$PreserveClientIp",
  272    272   
        "com.amazonaws.ec2",
  273    273   
        "Ec2InstanceConnectEndpoint",
  274    274   
    ),
  275    275   
    ::aws_smithy_schema::ShapeType::Boolean,
  276         -
    "preserve_client_ip",
         276  +
    "PreserveClientIp",
  277    277   
    12,
  278    278   
)
  279    279   
.with_xml_name("preserveClientIp");
  280    280   
static EC2INSTANCECONNECTENDPOINT_MEMBER_SECURITY_GROUP_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  281    281   
    ::aws_smithy_schema::ShapeId::from_static(
  282    282   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$SecurityGroupIds",
  283    283   
        "com.amazonaws.ec2",
  284    284   
        "Ec2InstanceConnectEndpoint",
  285    285   
    ),
  286    286   
    ::aws_smithy_schema::ShapeType::List,
  287         -
    "security_group_ids",
         287  +
    "SecurityGroupIds",
  288    288   
    13,
  289    289   
)
  290    290   
.with_xml_name("securityGroupIdSet");
  291    291   
static EC2INSTANCECONNECTENDPOINT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  292    292   
    ::aws_smithy_schema::ShapeId::from_static(
  293    293   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$Tags",
  294    294   
        "com.amazonaws.ec2",
  295    295   
        "Ec2InstanceConnectEndpoint",
  296    296   
    ),
  297    297   
    ::aws_smithy_schema::ShapeType::List,
  298         -
    "tags",
         298  +
    "Tags",
  299    299   
    14,
  300    300   
)
  301    301   
.with_xml_name("tagSet");
  302    302   
static EC2INSTANCECONNECTENDPOINT_MEMBER_IP_ADDRESS_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  303    303   
    ::aws_smithy_schema::ShapeId::from_static(
  304    304   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$IpAddressType",
  305    305   
        "com.amazonaws.ec2",
  306    306   
        "Ec2InstanceConnectEndpoint",
  307    307   
    ),
  308    308   
    ::aws_smithy_schema::ShapeType::String,
  309         -
    "ip_address_type",
         309  +
    "IpAddressType",
  310    310   
    15,
  311    311   
)
  312    312   
.with_xml_name("ipAddressType");
  313    313   
static EC2INSTANCECONNECTENDPOINT_MEMBER_PUBLIC_DNS_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  314    314   
    ::aws_smithy_schema::ShapeId::from_static(
  315    315   
        "com.amazonaws.ec2#Ec2InstanceConnectEndpoint$PublicDnsNames",
  316    316   
        "com.amazonaws.ec2",
  317    317   
        "Ec2InstanceConnectEndpoint",
  318    318   
    ),
  319    319   
    ::aws_smithy_schema::ShapeType::Structure,
  320         -
    "public_dns_names",
         320  +
    "PublicDnsNames",
  321    321   
    16,
  322    322   
)
  323    323   
.with_xml_name("publicDnsNames");
  324    324   
static EC2INSTANCECONNECTENDPOINT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  325    325   
    EC2INSTANCECONNECTENDPOINT_SCHEMA_ID,
  326    326   
    ::aws_smithy_schema::ShapeType::Structure,
  327    327   
    &[
  328    328   
        &EC2INSTANCECONNECTENDPOINT_MEMBER_OWNER_ID,
  329    329   
        &EC2INSTANCECONNECTENDPOINT_MEMBER_INSTANCE_CONNECT_ENDPOINT_ID,
  330    330   
        &EC2INSTANCECONNECTENDPOINT_MEMBER_INSTANCE_CONNECT_ENDPOINT_ARN,
@@ -407,407 +568,556 @@
  427    427   
            ser.write_string(&EC2INSTANCECONNECTENDPOINT_MEMBER_IP_ADDRESS_TYPE, val.as_str())?;
  428    428   
        }
  429    429   
        if let Some(ref val) = self.public_dns_names {
  430    430   
            ser.write_struct(&EC2INSTANCECONNECTENDPOINT_MEMBER_PUBLIC_DNS_NAMES, val)?;
  431    431   
        }
  432    432   
        Ok(())
  433    433   
    }
  434    434   
}
  435    435   
impl Ec2InstanceConnectEndpoint {
  436    436   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  437         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  438         -
        deserializer: &mut D,
         437  +
    pub fn deserialize(
         438  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  439    439   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  440    440   
        #[allow(unused_variables, unused_mut)]
  441    441   
        let mut builder = Self::builder();
  442    442   
        #[allow(
  443    443   
            unused_variables,
  444    444   
            unreachable_code,
  445    445   
            clippy::single_match,
  446    446   
            clippy::match_single_binding,
  447    447   
            clippy::diverging_sub_expression
  448    448   
        )]
  449         -
        deserializer.read_struct(&EC2INSTANCECONNECTENDPOINT_SCHEMA, (), |_, member, deser| {
         449  +
        deserializer.read_struct(&EC2INSTANCECONNECTENDPOINT_SCHEMA, &mut |member, deser| {
  450    450   
            match member.member_index() {
  451    451   
                Some(0) => {
  452    452   
                    builder.owner_id = Some(deser.read_string(member)?);
  453    453   
                }
  454    454   
                Some(1) => {
  455    455   
                    builder.instance_connect_endpoint_id = Some(deser.read_string(member)?);
  456    456   
                }
  457    457   
                Some(2) => {
  458    458   
                    builder.instance_connect_endpoint_arn = Some(deser.read_string(member)?);
  459    459   
                }
  460    460   
                Some(3) => {
  461    461   
                    builder.state = Some(crate::types::Ec2InstanceConnectEndpointState::from(deser.read_string(member)?.as_str()));
  462    462   
                }
  463    463   
                Some(4) => {
  464    464   
                    builder.state_message = Some(deser.read_string(member)?);
  465    465   
                }
  466    466   
                Some(5) => {
  467    467   
                    builder.dns_name = Some(deser.read_string(member)?);
  468    468   
                }
  469    469   
                Some(6) => {
  470    470   
                    builder.fips_dns_name = Some(deser.read_string(member)?);
  471    471   
                }
  472    472   
                Some(7) => {
  473         -
                    builder.network_interface_ids = Some({
  474         -
                        let container = if let Some(cap) = deser.container_size() {
  475         -
                            Vec::with_capacity(cap)
  476         -
                        } else {
  477         -
                            Vec::new()
  478         -
                        };
  479         -
                        deser.read_list(member, container, |mut list, deser| {
  480         -
                            list.push(deser.read_string(member)?);
  481         -
                            Ok(list)
  482         -
                        })?
  483         -
                    });
         473  +
                    builder.network_interface_ids = Some(deser.read_string_list(member)?);
  484    474   
                }
  485    475   
                Some(8) => {
  486    476   
                    builder.vpc_id = Some(deser.read_string(member)?);
  487    477   
                }
  488    478   
                Some(9) => {
  489    479   
                    builder.availability_zone = Some(deser.read_string(member)?);
  490    480   
                }
  491    481   
                Some(10) => {
  492    482   
                    builder.created_at = Some(deser.read_timestamp(member)?);
  493    483   
                }
  494    484   
                Some(11) => {
  495    485   
                    builder.subnet_id = Some(deser.read_string(member)?);
  496    486   
                }
  497    487   
                Some(12) => {
  498    488   
                    builder.preserve_client_ip = Some(deser.read_boolean(member)?);
  499    489   
                }
  500    490   
                Some(13) => {
  501         -
                    builder.security_group_ids = Some({
  502         -
                        let container = if let Some(cap) = deser.container_size() {
  503         -
                            Vec::with_capacity(cap)
  504         -
                        } else {
  505         -
                            Vec::new()
  506         -
                        };
  507         -
                        deser.read_list(member, container, |mut list, deser| {
  508         -
                            list.push(deser.read_string(member)?);
  509         -
                            Ok(list)
  510         -
                        })?
  511         -
                    });
         491  +
                    builder.security_group_ids = Some(deser.read_string_list(member)?);
  512    492   
                }
  513    493   
                Some(14) => {
  514    494   
                    builder.tags = Some({
  515         -
                        let container = if let Some(cap) = deser.container_size() {
  516         -
                            Vec::with_capacity(cap)
  517         -
                        } else {
  518         -
                            Vec::new()
  519         -
                        };
  520         -
                        deser.read_list(member, container, |mut list, deser| {
  521         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  522         -
                            Ok(list)
  523         -
                        })?
         495  +
                        let mut container = Vec::new();
         496  +
                        deser.read_list(member, &mut |deser| {
         497  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         498  +
                            Ok(())
         499  +
                        })?;
         500  +
                        container
  524    501   
                    });
  525    502   
                }
  526    503   
                Some(15) => {
  527    504   
                    builder.ip_address_type = Some(crate::types::IpAddressType::from(deser.read_string(member)?.as_str()));
  528    505   
                }
  529    506   
                Some(16) => {
  530    507   
                    builder.public_dns_names = Some(crate::types::InstanceConnectEndpointPublicDnsNames::deserialize(deser)?);
  531    508   
                }
  532    509   
                _ => {}
  533    510   
            }
  534    511   
            Ok(())
  535    512   
        })?;
  536    513   
        Ok(builder.build())
  537    514   
    }
  538    515   
}
         516  +
impl Ec2InstanceConnectEndpoint {
         517  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         518  +
    pub fn deserialize_with_response(
         519  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         520  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         521  +
        _status: u16,
         522  +
        _body: &[u8],
         523  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         524  +
        Self::deserialize(deserializer)
         525  +
    }
         526  +
}
  539    527   
impl Ec2InstanceConnectEndpoint {
  540    528   
    /// Creates a new builder-style object to manufacture [`Ec2InstanceConnectEndpoint`](crate::types::Ec2InstanceConnectEndpoint).
  541    529   
    pub fn builder() -> crate::types::builders::Ec2InstanceConnectEndpointBuilder {
  542    530   
        crate::types::builders::Ec2InstanceConnectEndpointBuilder::default()
  543    531   
    }
  544    532   
}
  545    533   
  546    534   
/// A builder for [`Ec2InstanceConnectEndpoint`](crate::types::Ec2InstanceConnectEndpoint).
  547    535   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  548    536   
#[non_exhaustive]

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

@@ -1,1 +101,112 @@
   11     11   
    /// <p>The maximum number of Elastic Fabric Adapters for the instance type.</p>
   12     12   
    pub fn maximum_efa_interfaces(&self) -> ::std::option::Option<i32> {
   13     13   
        self.maximum_efa_interfaces
   14     14   
    }
   15     15   
}
   16     16   
static EFAINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#EfaInfo", "com.amazonaws.ec2", "EfaInfo");
   18     18   
static EFAINFO_MEMBER_MAXIMUM_EFA_INTERFACES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#EfaInfo$MaximumEfaInterfaces", "com.amazonaws.ec2", "EfaInfo"),
   20     20   
    ::aws_smithy_schema::ShapeType::Integer,
   21         -
    "maximum_efa_interfaces",
          21  +
    "MaximumEfaInterfaces",
   22     22   
    0,
   23     23   
)
   24     24   
.with_xml_name("maximumEfaInterfaces");
   25     25   
static EFAINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   26     26   
    EFAINFO_SCHEMA_ID,
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28     28   
    &[&EFAINFO_MEMBER_MAXIMUM_EFA_INTERFACES],
   29     29   
);
   30     30   
impl EfaInfo {
   31     31   
    /// The schema for this shape.
   32     32   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EFAINFO_SCHEMA;
   33     33   
}
   34     34   
impl ::aws_smithy_schema::serde::SerializableStruct for EfaInfo {
   35     35   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   36     36   
    fn serialize_members(
   37     37   
        &self,
   38     38   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   39     39   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   40     40   
        if let Some(ref val) = self.maximum_efa_interfaces {
   41     41   
            ser.write_integer(&EFAINFO_MEMBER_MAXIMUM_EFA_INTERFACES, *val)?;
   42     42   
        }
   43     43   
        Ok(())
   44     44   
    }
   45     45   
}
   46     46   
impl EfaInfo {
   47     47   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   48         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   49         -
        deserializer: &mut D,
          48  +
    pub fn deserialize(
          49  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   50     50   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   51     51   
        #[allow(unused_variables, unused_mut)]
   52     52   
        let mut builder = Self::builder();
   53     53   
        #[allow(
   54     54   
            unused_variables,
   55     55   
            unreachable_code,
   56     56   
            clippy::single_match,
   57     57   
            clippy::match_single_binding,
   58     58   
            clippy::diverging_sub_expression
   59     59   
        )]
   60         -
        deserializer.read_struct(&EFAINFO_SCHEMA, (), |_, member, deser| {
          60  +
        deserializer.read_struct(&EFAINFO_SCHEMA, &mut |member, deser| {
   61     61   
            match member.member_index() {
   62     62   
                Some(0) => {
   63     63   
                    builder.maximum_efa_interfaces = Some(deser.read_integer(member)?);
   64     64   
                }
   65     65   
                _ => {}
   66     66   
            }
   67     67   
            Ok(())
   68     68   
        })?;
   69     69   
        Ok(builder.build())
   70     70   
    }
   71     71   
}
          72  +
impl EfaInfo {
          73  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          74  +
    pub fn deserialize_with_response(
          75  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          76  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          77  +
        _status: u16,
          78  +
        _body: &[u8],
          79  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          80  +
        Self::deserialize(deserializer)
          81  +
    }
          82  +
}
   72     83   
impl EfaInfo {
   73     84   
    /// Creates a new builder-style object to manufacture [`EfaInfo`](crate::types::EfaInfo).
   74     85   
    pub fn builder() -> crate::types::builders::EfaInfoBuilder {
   75     86   
        crate::types::builders::EfaInfoBuilder::default()
   76     87   
    }
   77     88   
}
   78     89   
   79     90   
/// A builder for [`EfaInfo`](crate::types::EfaInfo).
   80     91   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   81     92   
#[non_exhaustive]

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

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

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

@@ -16,16 +182,193 @@
   36     36   
}
   37     37   
static ELASTICGPUASSOCIATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   38     38   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ElasticGpuAssociation", "com.amazonaws.ec2", "ElasticGpuAssociation");
   39     39   
static ELASTICGPUASSOCIATION_MEMBER_ELASTIC_GPU_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.ec2#ElasticGpuAssociation$ElasticGpuId",
   42     42   
        "com.amazonaws.ec2",
   43     43   
        "ElasticGpuAssociation",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "elastic_gpu_id",
          46  +
    "ElasticGpuId",
   47     47   
    0,
   48     48   
)
   49     49   
.with_xml_name("elasticGpuId");
   50     50   
static ELASTICGPUASSOCIATION_MEMBER_ELASTIC_GPU_ASSOCIATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.ec2#ElasticGpuAssociation$ElasticGpuAssociationId",
   53     53   
        "com.amazonaws.ec2",
   54     54   
        "ElasticGpuAssociation",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "elastic_gpu_association_id",
          57  +
    "ElasticGpuAssociationId",
   58     58   
    1,
   59     59   
)
   60     60   
.with_xml_name("elasticGpuAssociationId");
   61     61   
static ELASTICGPUASSOCIATION_MEMBER_ELASTIC_GPU_ASSOCIATION_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.ec2#ElasticGpuAssociation$ElasticGpuAssociationState",
   64     64   
        "com.amazonaws.ec2",
   65     65   
        "ElasticGpuAssociation",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::String,
   68         -
    "elastic_gpu_association_state",
          68  +
    "ElasticGpuAssociationState",
   69     69   
    2,
   70     70   
)
   71     71   
.with_xml_name("elasticGpuAssociationState");
   72     72   
static ELASTICGPUASSOCIATION_MEMBER_ELASTIC_GPU_ASSOCIATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.ec2#ElasticGpuAssociation$ElasticGpuAssociationTime",
   75     75   
        "com.amazonaws.ec2",
   76     76   
        "ElasticGpuAssociation",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "elastic_gpu_association_time",
          79  +
    "ElasticGpuAssociationTime",
   80     80   
    3,
   81     81   
)
   82     82   
.with_xml_name("elasticGpuAssociationTime");
   83     83   
static ELASTICGPUASSOCIATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   84     84   
    ELASTICGPUASSOCIATION_SCHEMA_ID,
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86     86   
    &[
   87     87   
        &ELASTICGPUASSOCIATION_MEMBER_ELASTIC_GPU_ID,
   88     88   
        &ELASTICGPUASSOCIATION_MEMBER_ELASTIC_GPU_ASSOCIATION_ID,
   89     89   
        &ELASTICGPUASSOCIATION_MEMBER_ELASTIC_GPU_ASSOCIATION_STATE,
   90     90   
        &ELASTICGPUASSOCIATION_MEMBER_ELASTIC_GPU_ASSOCIATION_TIME,
   91     91   
    ],
   92     92   
);
   93     93   
impl ElasticGpuAssociation {
   94     94   
    /// The schema for this shape.
   95     95   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ELASTICGPUASSOCIATION_SCHEMA;
   96     96   
}
   97     97   
impl ::aws_smithy_schema::serde::SerializableStruct for ElasticGpuAssociation {
   98     98   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   99     99   
    fn serialize_members(
  100    100   
        &self,
  101    101   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  102    102   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  103    103   
        if let Some(ref val) = self.elastic_gpu_id {
  104    104   
            ser.write_string(&ELASTICGPUASSOCIATION_MEMBER_ELASTIC_GPU_ID, val)?;
  105    105   
        }
  106    106   
        if let Some(ref val) = self.elastic_gpu_association_id {
  107    107   
            ser.write_string(&ELASTICGPUASSOCIATION_MEMBER_ELASTIC_GPU_ASSOCIATION_ID, val)?;
  108    108   
        }
  109    109   
        if let Some(ref val) = self.elastic_gpu_association_state {
  110    110   
            ser.write_string(&ELASTICGPUASSOCIATION_MEMBER_ELASTIC_GPU_ASSOCIATION_STATE, val)?;
  111    111   
        }
  112    112   
        if let Some(ref val) = self.elastic_gpu_association_time {
  113    113   
            ser.write_string(&ELASTICGPUASSOCIATION_MEMBER_ELASTIC_GPU_ASSOCIATION_TIME, val)?;
  114    114   
        }
  115    115   
        Ok(())
  116    116   
    }
  117    117   
}
  118    118   
impl ElasticGpuAssociation {
  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(&ELASTICGPUASSOCIATION_SCHEMA, (), |_, member, deser| {
         132  +
        deserializer.read_struct(&ELASTICGPUASSOCIATION_SCHEMA, &mut |member, deser| {
  133    133   
            match member.member_index() {
  134    134   
                Some(0) => {
  135    135   
                    builder.elastic_gpu_id = Some(deser.read_string(member)?);
  136    136   
                }
  137    137   
                Some(1) => {
  138    138   
                    builder.elastic_gpu_association_id = Some(deser.read_string(member)?);
  139    139   
                }
  140    140   
                Some(2) => {
  141    141   
                    builder.elastic_gpu_association_state = Some(deser.read_string(member)?);
  142    142   
                }
  143    143   
                Some(3) => {
  144    144   
                    builder.elastic_gpu_association_time = Some(deser.read_string(member)?);
  145    145   
                }
  146    146   
                _ => {}
  147    147   
            }
  148    148   
            Ok(())
  149    149   
        })?;
  150    150   
        Ok(builder.build())
  151    151   
    }
  152    152   
}
         153  +
impl ElasticGpuAssociation {
         154  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         155  +
    pub fn deserialize_with_response(
         156  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         157  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         158  +
        _status: u16,
         159  +
        _body: &[u8],
         160  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         161  +
        Self::deserialize(deserializer)
         162  +
    }
         163  +
}
  153    164   
impl ElasticGpuAssociation {
  154    165   
    /// Creates a new builder-style object to manufacture [`ElasticGpuAssociation`](crate::types::ElasticGpuAssociation).
  155    166   
    pub fn builder() -> crate::types::builders::ElasticGpuAssociationBuilder {
  156    167   
        crate::types::builders::ElasticGpuAssociationBuilder::default()
  157    168   
    }
  158    169   
}
  159    170   
  160    171   
/// A builder for [`ElasticGpuAssociation`](crate::types::ElasticGpuAssociation).
  161    172   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  162    173   
#[non_exhaustive]

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

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

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

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

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

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

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

@@ -32,32 +243,251 @@
   52     52   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
   53     53   
    pub fn tags(&self) -> &[crate::types::Tag] {
   54     54   
        self.tags.as_deref().unwrap_or_default()
   55     55   
    }
   56     56   
}
   57     57   
static ELASTICGPUS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   58     58   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ElasticGpus", "com.amazonaws.ec2", "ElasticGpus");
   59     59   
static ELASTICGPUS_MEMBER_ELASTIC_GPU_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ElasticGpus$ElasticGpuId", "com.amazonaws.ec2", "ElasticGpus"),
   61     61   
    ::aws_smithy_schema::ShapeType::String,
   62         -
    "elastic_gpu_id",
          62  +
    "ElasticGpuId",
   63     63   
    0,
   64     64   
)
   65     65   
.with_xml_name("elasticGpuId");
   66     66   
static ELASTICGPUS_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ElasticGpus$AvailabilityZone", "com.amazonaws.ec2", "ElasticGpus"),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "availability_zone",
          69  +
    "AvailabilityZone",
   70     70   
    1,
   71     71   
)
   72     72   
.with_xml_name("availabilityZone");
   73     73   
static ELASTICGPUS_MEMBER_ELASTIC_GPU_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ElasticGpus$ElasticGpuType", "com.amazonaws.ec2", "ElasticGpus"),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "elastic_gpu_type",
          76  +
    "ElasticGpuType",
   77     77   
    2,
   78     78   
)
   79     79   
.with_xml_name("elasticGpuType");
   80     80   
static ELASTICGPUS_MEMBER_ELASTIC_GPU_HEALTH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ElasticGpus$ElasticGpuHealth", "com.amazonaws.ec2", "ElasticGpus"),
   82     82   
    ::aws_smithy_schema::ShapeType::Structure,
   83         -
    "elastic_gpu_health",
          83  +
    "ElasticGpuHealth",
   84     84   
    3,
   85     85   
)
   86     86   
.with_xml_name("elasticGpuHealth");
   87     87   
static ELASTICGPUS_MEMBER_ELASTIC_GPU_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ElasticGpus$ElasticGpuState", "com.amazonaws.ec2", "ElasticGpus"),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "elastic_gpu_state",
          90  +
    "ElasticGpuState",
   91     91   
    4,
   92     92   
)
   93     93   
.with_xml_name("elasticGpuState");
   94     94   
static ELASTICGPUS_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ElasticGpus$InstanceId", "com.amazonaws.ec2", "ElasticGpus"),
   96     96   
    ::aws_smithy_schema::ShapeType::String,
   97         -
    "instance_id",
          97  +
    "InstanceId",
   98     98   
    5,
   99     99   
)
  100    100   
.with_xml_name("instanceId");
  101    101   
static ELASTICGPUS_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ElasticGpus$Tags", "com.amazonaws.ec2", "ElasticGpus"),
  103    103   
    ::aws_smithy_schema::ShapeType::List,
  104         -
    "tags",
         104  +
    "Tags",
  105    105   
    6,
  106    106   
)
  107    107   
.with_xml_name("tagSet");
  108    108   
static ELASTICGPUS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  109    109   
    ELASTICGPUS_SCHEMA_ID,
  110    110   
    ::aws_smithy_schema::ShapeType::Structure,
  111    111   
    &[
  112    112   
        &ELASTICGPUS_MEMBER_ELASTIC_GPU_ID,
  113    113   
        &ELASTICGPUS_MEMBER_AVAILABILITY_ZONE,
  114    114   
        &ELASTICGPUS_MEMBER_ELASTIC_GPU_TYPE,
  115    115   
        &ELASTICGPUS_MEMBER_ELASTIC_GPU_HEALTH,
  116    116   
        &ELASTICGPUS_MEMBER_ELASTIC_GPU_STATE,
  117    117   
        &ELASTICGPUS_MEMBER_INSTANCE_ID,
  118    118   
        &ELASTICGPUS_MEMBER_TAGS,
  119    119   
    ],
  120    120   
);
  121    121   
impl ElasticGpus {
  122    122   
    /// The schema for this shape.
  123    123   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ELASTICGPUS_SCHEMA;
  124    124   
}
  125    125   
impl ::aws_smithy_schema::serde::SerializableStruct for ElasticGpus {
  126    126   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  127    127   
    fn serialize_members(
  128    128   
        &self,
  129    129   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  130    130   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  131    131   
        if let Some(ref val) = self.elastic_gpu_id {
  132    132   
            ser.write_string(&ELASTICGPUS_MEMBER_ELASTIC_GPU_ID, val)?;
  133    133   
        }
  134    134   
        if let Some(ref val) = self.availability_zone {
  135    135   
            ser.write_string(&ELASTICGPUS_MEMBER_AVAILABILITY_ZONE, val)?;
  136    136   
        }
  137    137   
        if let Some(ref val) = self.elastic_gpu_type {
  138    138   
            ser.write_string(&ELASTICGPUS_MEMBER_ELASTIC_GPU_TYPE, val)?;
  139    139   
        }
  140    140   
        if let Some(ref val) = self.elastic_gpu_health {
  141    141   
            ser.write_struct(&ELASTICGPUS_MEMBER_ELASTIC_GPU_HEALTH, val)?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.elastic_gpu_state {
  144    144   
            ser.write_string(&ELASTICGPUS_MEMBER_ELASTIC_GPU_STATE, val.as_str())?;
  145    145   
        }
  146    146   
        if let Some(ref val) = self.instance_id {
  147    147   
            ser.write_string(&ELASTICGPUS_MEMBER_INSTANCE_ID, val)?;
  148    148   
        }
  149    149   
        if let Some(ref val) = self.tags {
  150    150   
            ser.write_list(&ELASTICGPUS_MEMBER_TAGS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  151    151   
                for item in val {
  152    152   
                    ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  153    153   
                }
  154    154   
                Ok(())
  155    155   
            })?;
  156    156   
        }
  157    157   
        Ok(())
  158    158   
    }
  159    159   
}
  160    160   
impl ElasticGpus {
  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(&ELASTICGPUS_SCHEMA, (), |_, member, deser| {
         174  +
        deserializer.read_struct(&ELASTICGPUS_SCHEMA, &mut |member, deser| {
  175    175   
            match member.member_index() {
  176    176   
                Some(0) => {
  177    177   
                    builder.elastic_gpu_id = Some(deser.read_string(member)?);
  178    178   
                }
  179    179   
                Some(1) => {
  180    180   
                    builder.availability_zone = Some(deser.read_string(member)?);
  181    181   
                }
  182    182   
                Some(2) => {
  183    183   
                    builder.elastic_gpu_type = Some(deser.read_string(member)?);
  184    184   
                }
  185    185   
                Some(3) => {
  186    186   
                    builder.elastic_gpu_health = Some(crate::types::ElasticGpuHealth::deserialize(deser)?);
  187    187   
                }
  188    188   
                Some(4) => {
  189    189   
                    builder.elastic_gpu_state = Some(crate::types::ElasticGpuState::from(deser.read_string(member)?.as_str()));
  190    190   
                }
  191    191   
                Some(5) => {
  192    192   
                    builder.instance_id = Some(deser.read_string(member)?);
  193    193   
                }
  194    194   
                Some(6) => {
  195    195   
                    builder.tags = Some({
  196         -
                        let container = if let Some(cap) = deser.container_size() {
  197         -
                            Vec::with_capacity(cap)
  198         -
                        } else {
  199         -
                            Vec::new()
  200         -
                        };
  201         -
                        deser.read_list(member, container, |mut list, deser| {
  202         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  203         -
                            Ok(list)
  204         -
                        })?
         196  +
                        let mut container = Vec::new();
         197  +
                        deser.read_list(member, &mut |deser| {
         198  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         199  +
                            Ok(())
         200  +
                        })?;
         201  +
                        container
  205    202   
                    });
  206    203   
                }
  207    204   
                _ => {}
  208    205   
            }
  209    206   
            Ok(())
  210    207   
        })?;
  211    208   
        Ok(builder.build())
  212    209   
    }
  213    210   
}
         211  +
impl ElasticGpus {
         212  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         213  +
    pub fn deserialize_with_response(
         214  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         215  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         216  +
        _status: u16,
         217  +
        _body: &[u8],
         218  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         219  +
        Self::deserialize(deserializer)
         220  +
    }
         221  +
}
  214    222   
impl ElasticGpus {
  215    223   
    /// Creates a new builder-style object to manufacture [`ElasticGpus`](crate::types::ElasticGpus).
  216    224   
    pub fn builder() -> crate::types::builders::ElasticGpusBuilder {
  217    225   
        crate::types::builders::ElasticGpusBuilder::default()
  218    226   
    }
  219    227   
}
  220    228   
  221    229   
/// A builder for [`ElasticGpus`](crate::types::ElasticGpus).
  222    230   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  223    231   
#[non_exhaustive]

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

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

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

@@ -20,20 +198,209 @@
   40     40   
    "ElasticInferenceAcceleratorAssociation",
   41     41   
);
   42     42   
static ELASTICINFERENCEACCELERATORASSOCIATION_MEMBER_ELASTIC_INFERENCE_ACCELERATOR_ARN: ::aws_smithy_schema::Schema =
   43     43   
    ::aws_smithy_schema::Schema::new_member(
   44     44   
        ::aws_smithy_schema::ShapeId::from_static(
   45     45   
            "com.amazonaws.ec2#ElasticInferenceAcceleratorAssociation$ElasticInferenceAcceleratorArn",
   46     46   
            "com.amazonaws.ec2",
   47     47   
            "ElasticInferenceAcceleratorAssociation",
   48     48   
        ),
   49     49   
        ::aws_smithy_schema::ShapeType::String,
   50         -
        "elastic_inference_accelerator_arn",
          50  +
        "ElasticInferenceAcceleratorArn",
   51     51   
        0,
   52     52   
    )
   53     53   
    .with_xml_name("elasticInferenceAcceleratorArn");
   54     54   
static ELASTICINFERENCEACCELERATORASSOCIATION_MEMBER_ELASTIC_INFERENCE_ACCELERATOR_ASSOCIATION_ID: ::aws_smithy_schema::Schema =
   55     55   
    ::aws_smithy_schema::Schema::new_member(
   56     56   
        ::aws_smithy_schema::ShapeId::from_static(
   57     57   
            "com.amazonaws.ec2#ElasticInferenceAcceleratorAssociation$ElasticInferenceAcceleratorAssociationId",
   58     58   
            "com.amazonaws.ec2",
   59     59   
            "ElasticInferenceAcceleratorAssociation",
   60     60   
        ),
   61     61   
        ::aws_smithy_schema::ShapeType::String,
   62         -
        "elastic_inference_accelerator_association_id",
          62  +
        "ElasticInferenceAcceleratorAssociationId",
   63     63   
        1,
   64     64   
    )
   65     65   
    .with_xml_name("elasticInferenceAcceleratorAssociationId");
   66     66   
static ELASTICINFERENCEACCELERATORASSOCIATION_MEMBER_ELASTIC_INFERENCE_ACCELERATOR_ASSOCIATION_STATE: ::aws_smithy_schema::Schema =
   67     67   
    ::aws_smithy_schema::Schema::new_member(
   68     68   
        ::aws_smithy_schema::ShapeId::from_static(
   69     69   
            "com.amazonaws.ec2#ElasticInferenceAcceleratorAssociation$ElasticInferenceAcceleratorAssociationState",
   70     70   
            "com.amazonaws.ec2",
   71     71   
            "ElasticInferenceAcceleratorAssociation",
   72     72   
        ),
   73     73   
        ::aws_smithy_schema::ShapeType::String,
   74         -
        "elastic_inference_accelerator_association_state",
          74  +
        "ElasticInferenceAcceleratorAssociationState",
   75     75   
        2,
   76     76   
    )
   77     77   
    .with_xml_name("elasticInferenceAcceleratorAssociationState");
   78     78   
static ELASTICINFERENCEACCELERATORASSOCIATION_MEMBER_ELASTIC_INFERENCE_ACCELERATOR_ASSOCIATION_TIME: ::aws_smithy_schema::Schema =
   79     79   
    ::aws_smithy_schema::Schema::new_member(
   80     80   
        ::aws_smithy_schema::ShapeId::from_static(
   81     81   
            "com.amazonaws.ec2#ElasticInferenceAcceleratorAssociation$ElasticInferenceAcceleratorAssociationTime",
   82     82   
            "com.amazonaws.ec2",
   83     83   
            "ElasticInferenceAcceleratorAssociation",
   84     84   
        ),
   85     85   
        ::aws_smithy_schema::ShapeType::Timestamp,
   86         -
        "elastic_inference_accelerator_association_time",
          86  +
        "ElasticInferenceAcceleratorAssociationTime",
   87     87   
        3,
   88     88   
    )
   89     89   
    .with_xml_name("elasticInferenceAcceleratorAssociationTime");
   90     90   
static ELASTICINFERENCEACCELERATORASSOCIATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   91     91   
    ELASTICINFERENCEACCELERATORASSOCIATION_SCHEMA_ID,
   92     92   
    ::aws_smithy_schema::ShapeType::Structure,
   93     93   
    &[
   94     94   
        &ELASTICINFERENCEACCELERATORASSOCIATION_MEMBER_ELASTIC_INFERENCE_ACCELERATOR_ARN,
   95     95   
        &ELASTICINFERENCEACCELERATORASSOCIATION_MEMBER_ELASTIC_INFERENCE_ACCELERATOR_ASSOCIATION_ID,
   96     96   
        &ELASTICINFERENCEACCELERATORASSOCIATION_MEMBER_ELASTIC_INFERENCE_ACCELERATOR_ASSOCIATION_STATE,
   97     97   
        &ELASTICINFERENCEACCELERATORASSOCIATION_MEMBER_ELASTIC_INFERENCE_ACCELERATOR_ASSOCIATION_TIME,
   98     98   
    ],
   99     99   
);
  100    100   
impl ElasticInferenceAcceleratorAssociation {
  101    101   
    /// The schema for this shape.
  102    102   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ELASTICINFERENCEACCELERATORASSOCIATION_SCHEMA;
  103    103   
}
  104    104   
impl ::aws_smithy_schema::serde::SerializableStruct for ElasticInferenceAcceleratorAssociation {
  105    105   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  106    106   
    fn serialize_members(
  107    107   
        &self,
  108    108   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  109    109   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  110    110   
        if let Some(ref val) = self.elastic_inference_accelerator_arn {
  111    111   
            ser.write_string(&ELASTICINFERENCEACCELERATORASSOCIATION_MEMBER_ELASTIC_INFERENCE_ACCELERATOR_ARN, val)?;
  112    112   
        }
  113    113   
        if let Some(ref val) = self.elastic_inference_accelerator_association_id {
  114    114   
            ser.write_string(
  115    115   
                &ELASTICINFERENCEACCELERATORASSOCIATION_MEMBER_ELASTIC_INFERENCE_ACCELERATOR_ASSOCIATION_ID,
  116    116   
                val,
  117    117   
            )?;
  118    118   
        }
  119    119   
        if let Some(ref val) = self.elastic_inference_accelerator_association_state {
  120    120   
            ser.write_string(
  121    121   
                &ELASTICINFERENCEACCELERATORASSOCIATION_MEMBER_ELASTIC_INFERENCE_ACCELERATOR_ASSOCIATION_STATE,
  122    122   
                val,
  123    123   
            )?;
  124    124   
        }
  125    125   
        if let Some(ref val) = self.elastic_inference_accelerator_association_time {
  126    126   
            ser.write_timestamp(
  127    127   
                &ELASTICINFERENCEACCELERATORASSOCIATION_MEMBER_ELASTIC_INFERENCE_ACCELERATOR_ASSOCIATION_TIME,
  128    128   
                val,
  129    129   
            )?;
  130    130   
        }
  131    131   
        Ok(())
  132    132   
    }
  133    133   
}
  134    134   
impl ElasticInferenceAcceleratorAssociation {
  135    135   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  136         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  137         -
        deserializer: &mut D,
         136  +
    pub fn deserialize(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  138    138   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  139    139   
        #[allow(unused_variables, unused_mut)]
  140    140   
        let mut builder = Self::builder();
  141    141   
        #[allow(
  142    142   
            unused_variables,
  143    143   
            unreachable_code,
  144    144   
            clippy::single_match,
  145    145   
            clippy::match_single_binding,
  146    146   
            clippy::diverging_sub_expression
  147    147   
        )]
  148         -
        deserializer.read_struct(&ELASTICINFERENCEACCELERATORASSOCIATION_SCHEMA, (), |_, member, deser| {
         148  +
        deserializer.read_struct(&ELASTICINFERENCEACCELERATORASSOCIATION_SCHEMA, &mut |member, deser| {
  149    149   
            match member.member_index() {
  150    150   
                Some(0) => {
  151    151   
                    builder.elastic_inference_accelerator_arn = Some(deser.read_string(member)?);
  152    152   
                }
  153    153   
                Some(1) => {
  154    154   
                    builder.elastic_inference_accelerator_association_id = Some(deser.read_string(member)?);
  155    155   
                }
  156    156   
                Some(2) => {
  157    157   
                    builder.elastic_inference_accelerator_association_state = Some(deser.read_string(member)?);
  158    158   
                }
  159    159   
                Some(3) => {
  160    160   
                    builder.elastic_inference_accelerator_association_time = Some(deser.read_timestamp(member)?);
  161    161   
                }
  162    162   
                _ => {}
  163    163   
            }
  164    164   
            Ok(())
  165    165   
        })?;
  166    166   
        Ok(builder.build())
  167    167   
    }
  168    168   
}
         169  +
impl ElasticInferenceAcceleratorAssociation {
         170  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         171  +
    pub fn deserialize_with_response(
         172  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         173  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         174  +
        _status: u16,
         175  +
        _body: &[u8],
         176  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         177  +
        Self::deserialize(deserializer)
         178  +
    }
         179  +
}
  169    180   
impl ElasticInferenceAcceleratorAssociation {
  170    181   
    /// Creates a new builder-style object to manufacture [`ElasticInferenceAcceleratorAssociation`](crate::types::ElasticInferenceAcceleratorAssociation).
  171    182   
    pub fn builder() -> crate::types::builders::ElasticInferenceAcceleratorAssociationBuilder {
  172    183   
        crate::types::builders::ElasticInferenceAcceleratorAssociationBuilder::default()
  173    184   
    }
  174    185   
}
  175    186   
  176    187   
/// A builder for [`ElasticInferenceAcceleratorAssociation`](crate::types::ElasticInferenceAcceleratorAssociation).
  177    188   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  178    189   
#[non_exhaustive]

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

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

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

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

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

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