AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

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

@@ -1,1 +120,131 @@
   17     17   
    /// <p>The description.</p>
   18     18   
    pub fn description(&self) -> ::std::option::Option<&str> {
   19     19   
        self.description.as_deref()
   20     20   
    }
   21     21   
}
   22     22   
static PREFIXLISTENTRY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PrefixListEntry", "com.amazonaws.ec2", "PrefixListEntry");
   24     24   
static PREFIXLISTENTRY_MEMBER_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PrefixListEntry$Cidr", "com.amazonaws.ec2", "PrefixListEntry"),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "cidr",
          27  +
    "Cidr",
   28     28   
    0,
   29     29   
)
   30     30   
.with_xml_name("cidr");
   31     31   
static PREFIXLISTENTRY_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PrefixListEntry$Description", "com.amazonaws.ec2", "PrefixListEntry"),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "description",
          34  +
    "Description",
   35     35   
    1,
   36     36   
)
   37     37   
.with_xml_name("description");
   38     38   
static PREFIXLISTENTRY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    PREFIXLISTENTRY_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&PREFIXLISTENTRY_MEMBER_CIDR, &PREFIXLISTENTRY_MEMBER_DESCRIPTION],
   42     42   
);
   43     43   
impl PrefixListEntry {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PREFIXLISTENTRY_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for PrefixListEntry {
   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.cidr {
   54     54   
            ser.write_string(&PREFIXLISTENTRY_MEMBER_CIDR, val)?;
   55     55   
        }
   56     56   
        if let Some(ref val) = self.description {
   57     57   
            ser.write_string(&PREFIXLISTENTRY_MEMBER_DESCRIPTION, val)?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl PrefixListEntry {
   63     63   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   64         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   65         -
        deserializer: &mut D,
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   66     66   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        #[allow(unused_variables, unused_mut)]
   68     68   
        let mut builder = Self::builder();
   69     69   
        #[allow(
   70     70   
            unused_variables,
   71     71   
            unreachable_code,
   72     72   
            clippy::single_match,
   73     73   
            clippy::match_single_binding,
   74     74   
            clippy::diverging_sub_expression
   75     75   
        )]
   76         -
        deserializer.read_struct(&PREFIXLISTENTRY_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&PREFIXLISTENTRY_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.cidr = Some(deser.read_string(member)?);
   80     80   
                }
   81     81   
                Some(1) => {
   82     82   
                    builder.description = Some(deser.read_string(member)?);
   83     83   
                }
   84     84   
                _ => {}
   85     85   
            }
   86     86   
            Ok(())
   87     87   
        })?;
   88     88   
        Ok(builder.build())
   89     89   
    }
   90     90   
}
          91  +
impl PrefixListEntry {
          92  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          93  +
    pub fn deserialize_with_response(
          94  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          95  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          96  +
        _status: u16,
          97  +
        _body: &[u8],
          98  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          99  +
        Self::deserialize(deserializer)
         100  +
    }
         101  +
}
   91    102   
impl PrefixListEntry {
   92    103   
    /// Creates a new builder-style object to manufacture [`PrefixListEntry`](crate::types::PrefixListEntry).
   93    104   
    pub fn builder() -> crate::types::builders::PrefixListEntryBuilder {
   94    105   
        crate::types::builders::PrefixListEntryBuilder::default()
   95    106   
    }
   96    107   
}
   97    108   
   98    109   
/// A builder for [`PrefixListEntry`](crate::types::PrefixListEntry).
   99    110   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  100    111   
#[non_exhaustive]

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

@@ -1,1 +122,133 @@
   19     19   
    /// <p>The ID of the prefix.</p>
   20     20   
    pub fn prefix_list_id(&self) -> ::std::option::Option<&str> {
   21     21   
        self.prefix_list_id.as_deref()
   22     22   
    }
   23     23   
}
   24     24   
static PREFIXLISTID_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PrefixListId", "com.amazonaws.ec2", "PrefixListId");
   26     26   
static PREFIXLISTID_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PrefixListId$Description", "com.amazonaws.ec2", "PrefixListId"),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "description",
          29  +
    "Description",
   30     30   
    0,
   31     31   
)
   32     32   
.with_xml_name("description");
   33     33   
static PREFIXLISTID_MEMBER_PREFIX_LIST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PrefixListId$PrefixListId", "com.amazonaws.ec2", "PrefixListId"),
   35     35   
    ::aws_smithy_schema::ShapeType::String,
   36         -
    "prefix_list_id",
          36  +
    "PrefixListId",
   37     37   
    1,
   38     38   
)
   39     39   
.with_xml_name("prefixListId");
   40     40   
static PREFIXLISTID_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   41     41   
    PREFIXLISTID_SCHEMA_ID,
   42     42   
    ::aws_smithy_schema::ShapeType::Structure,
   43     43   
    &[&PREFIXLISTID_MEMBER_DESCRIPTION, &PREFIXLISTID_MEMBER_PREFIX_LIST_ID],
   44     44   
);
   45     45   
impl PrefixListId {
   46     46   
    /// The schema for this shape.
   47     47   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PREFIXLISTID_SCHEMA;
   48     48   
}
   49     49   
impl ::aws_smithy_schema::serde::SerializableStruct for PrefixListId {
   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.description {
   56     56   
            ser.write_string(&PREFIXLISTID_MEMBER_DESCRIPTION, val)?;
   57     57   
        }
   58     58   
        if let Some(ref val) = self.prefix_list_id {
   59     59   
            ser.write_string(&PREFIXLISTID_MEMBER_PREFIX_LIST_ID, val)?;
   60     60   
        }
   61     61   
        Ok(())
   62     62   
    }
   63     63   
}
   64     64   
impl PrefixListId {
   65     65   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   66         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   67         -
        deserializer: &mut D,
          66  +
    pub fn deserialize(
          67  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   68     68   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   69     69   
        #[allow(unused_variables, unused_mut)]
   70     70   
        let mut builder = Self::builder();
   71     71   
        #[allow(
   72     72   
            unused_variables,
   73     73   
            unreachable_code,
   74     74   
            clippy::single_match,
   75     75   
            clippy::match_single_binding,
   76     76   
            clippy::diverging_sub_expression
   77     77   
        )]
   78         -
        deserializer.read_struct(&PREFIXLISTID_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&PREFIXLISTID_SCHEMA, &mut |member, deser| {
   79     79   
            match member.member_index() {
   80     80   
                Some(0) => {
   81     81   
                    builder.description = Some(deser.read_string(member)?);
   82     82   
                }
   83     83   
                Some(1) => {
   84     84   
                    builder.prefix_list_id = Some(deser.read_string(member)?);
   85     85   
                }
   86     86   
                _ => {}
   87     87   
            }
   88     88   
            Ok(())
   89     89   
        })?;
   90     90   
        Ok(builder.build())
   91     91   
    }
   92     92   
}
          93  +
impl PrefixListId {
          94  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          95  +
    pub fn deserialize_with_response(
          96  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          97  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          98  +
        _status: u16,
          99  +
        _body: &[u8],
         100  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         101  +
        Self::deserialize(deserializer)
         102  +
    }
         103  +
}
   93    104   
impl PrefixListId {
   94    105   
    /// Creates a new builder-style object to manufacture [`PrefixListId`](crate::types::PrefixListId).
   95    106   
    pub fn builder() -> crate::types::builders::PrefixListIdBuilder {
   96    107   
        crate::types::builders::PrefixListIdBuilder::default()
   97    108   
    }
   98    109   
}
   99    110   
  100    111   
/// A builder for [`PrefixListId`](crate::types::PrefixListId).
  101    112   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  102    113   
#[non_exhaustive]

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

@@ -11,11 +165,176 @@
   31     31   
    /// <p>The number of months remaining in the reservation. For example, 2 is the second to the last month before the capacity reservation expires.</p>
   32     32   
    pub fn term(&self) -> ::std::option::Option<i64> {
   33     33   
        self.term
   34     34   
    }
   35     35   
}
   36     36   
static PRICESCHEDULE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PriceSchedule", "com.amazonaws.ec2", "PriceSchedule");
   38     38   
static PRICESCHEDULE_MEMBER_ACTIVE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PriceSchedule$Active", "com.amazonaws.ec2", "PriceSchedule"),
   40     40   
    ::aws_smithy_schema::ShapeType::Boolean,
   41         -
    "active",
          41  +
    "Active",
   42     42   
    0,
   43     43   
)
   44     44   
.with_xml_name("active");
   45     45   
static PRICESCHEDULE_MEMBER_CURRENCY_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PriceSchedule$CurrencyCode", "com.amazonaws.ec2", "PriceSchedule"),
   47     47   
    ::aws_smithy_schema::ShapeType::String,
   48         -
    "currency_code",
          48  +
    "CurrencyCode",
   49     49   
    1,
   50     50   
)
   51     51   
.with_xml_name("currencyCode");
   52     52   
static PRICESCHEDULE_MEMBER_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PriceSchedule$Price", "com.amazonaws.ec2", "PriceSchedule"),
   54     54   
    ::aws_smithy_schema::ShapeType::Double,
   55         -
    "price",
          55  +
    "Price",
   56     56   
    2,
   57     57   
)
   58     58   
.with_xml_name("price");
   59     59   
static PRICESCHEDULE_MEMBER_TERM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PriceSchedule$Term", "com.amazonaws.ec2", "PriceSchedule"),
   61     61   
    ::aws_smithy_schema::ShapeType::Long,
   62         -
    "term",
          62  +
    "Term",
   63     63   
    3,
   64     64   
)
   65     65   
.with_xml_name("term");
   66     66   
static PRICESCHEDULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   67     67   
    PRICESCHEDULE_SCHEMA_ID,
   68     68   
    ::aws_smithy_schema::ShapeType::Structure,
   69     69   
    &[
   70     70   
        &PRICESCHEDULE_MEMBER_ACTIVE,
   71     71   
        &PRICESCHEDULE_MEMBER_CURRENCY_CODE,
   72     72   
        &PRICESCHEDULE_MEMBER_PRICE,
   73     73   
        &PRICESCHEDULE_MEMBER_TERM,
   74     74   
    ],
   75     75   
);
   76     76   
impl PriceSchedule {
   77     77   
    /// The schema for this shape.
   78     78   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PRICESCHEDULE_SCHEMA;
   79     79   
}
   80     80   
impl ::aws_smithy_schema::serde::SerializableStruct for PriceSchedule {
   81     81   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   82     82   
    fn serialize_members(
   83     83   
        &self,
   84     84   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   85     85   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   86     86   
        if let Some(ref val) = self.active {
   87     87   
            ser.write_boolean(&PRICESCHEDULE_MEMBER_ACTIVE, *val)?;
   88     88   
        }
   89     89   
        if let Some(ref val) = self.currency_code {
   90     90   
            ser.write_string(&PRICESCHEDULE_MEMBER_CURRENCY_CODE, val.as_str())?;
   91     91   
        }
   92     92   
        if let Some(ref val) = self.price {
   93     93   
            ser.write_double(&PRICESCHEDULE_MEMBER_PRICE, *val)?;
   94     94   
        }
   95     95   
        if let Some(ref val) = self.term {
   96     96   
            ser.write_long(&PRICESCHEDULE_MEMBER_TERM, *val)?;
   97     97   
        }
   98     98   
        Ok(())
   99     99   
    }
  100    100   
}
  101    101   
impl PriceSchedule {
  102    102   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  103         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  104         -
        deserializer: &mut D,
         103  +
    pub fn deserialize(
         104  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  105    105   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  106    106   
        #[allow(unused_variables, unused_mut)]
  107    107   
        let mut builder = Self::builder();
  108    108   
        #[allow(
  109    109   
            unused_variables,
  110    110   
            unreachable_code,
  111    111   
            clippy::single_match,
  112    112   
            clippy::match_single_binding,
  113    113   
            clippy::diverging_sub_expression
  114    114   
        )]
  115         -
        deserializer.read_struct(&PRICESCHEDULE_SCHEMA, (), |_, member, deser| {
         115  +
        deserializer.read_struct(&PRICESCHEDULE_SCHEMA, &mut |member, deser| {
  116    116   
            match member.member_index() {
  117    117   
                Some(0) => {
  118    118   
                    builder.active = Some(deser.read_boolean(member)?);
  119    119   
                }
  120    120   
                Some(1) => {
  121    121   
                    builder.currency_code = Some(crate::types::CurrencyCodeValues::from(deser.read_string(member)?.as_str()));
  122    122   
                }
  123    123   
                Some(2) => {
  124    124   
                    builder.price = Some(deser.read_double(member)?);
  125    125   
                }
  126    126   
                Some(3) => {
  127    127   
                    builder.term = Some(deser.read_long(member)?);
  128    128   
                }
  129    129   
                _ => {}
  130    130   
            }
  131    131   
            Ok(())
  132    132   
        })?;
  133    133   
        Ok(builder.build())
  134    134   
    }
  135    135   
}
         136  +
impl PriceSchedule {
         137  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         138  +
    pub fn deserialize_with_response(
         139  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         140  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         141  +
        _status: u16,
         142  +
        _body: &[u8],
         143  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         144  +
        Self::deserialize(deserializer)
         145  +
    }
         146  +
}
  136    147   
impl PriceSchedule {
  137    148   
    /// Creates a new builder-style object to manufacture [`PriceSchedule`](crate::types::PriceSchedule).
  138    149   
    pub fn builder() -> crate::types::builders::PriceScheduleBuilder {
  139    150   
        crate::types::builders::PriceScheduleBuilder::default()
  140    151   
    }
  141    152   
}
  142    153   
  143    154   
/// A builder for [`PriceSchedule`](crate::types::PriceSchedule).
  144    155   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  145    156   
#[non_exhaustive]

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

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

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

@@ -1,1 +120,131 @@
   17     17   
    /// <p>The price per instance.</p>
   18     18   
    pub fn price(&self) -> ::std::option::Option<f64> {
   19     19   
        self.price
   20     20   
    }
   21     21   
}
   22     22   
static PRICINGDETAIL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PricingDetail", "com.amazonaws.ec2", "PricingDetail");
   24     24   
static PRICINGDETAIL_MEMBER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PricingDetail$Count", "com.amazonaws.ec2", "PricingDetail"),
   26     26   
    ::aws_smithy_schema::ShapeType::Integer,
   27         -
    "count",
          27  +
    "Count",
   28     28   
    0,
   29     29   
)
   30     30   
.with_xml_name("count");
   31     31   
static PRICINGDETAIL_MEMBER_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PricingDetail$Price", "com.amazonaws.ec2", "PricingDetail"),
   33     33   
    ::aws_smithy_schema::ShapeType::Double,
   34         -
    "price",
          34  +
    "Price",
   35     35   
    1,
   36     36   
)
   37     37   
.with_xml_name("price");
   38     38   
static PRICINGDETAIL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    PRICINGDETAIL_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&PRICINGDETAIL_MEMBER_COUNT, &PRICINGDETAIL_MEMBER_PRICE],
   42     42   
);
   43     43   
impl PricingDetail {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PRICINGDETAIL_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for PricingDetail {
   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.count {
   54     54   
            ser.write_integer(&PRICINGDETAIL_MEMBER_COUNT, *val)?;
   55     55   
        }
   56     56   
        if let Some(ref val) = self.price {
   57     57   
            ser.write_double(&PRICINGDETAIL_MEMBER_PRICE, *val)?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl PricingDetail {
   63     63   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   64         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   65         -
        deserializer: &mut D,
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   66     66   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        #[allow(unused_variables, unused_mut)]
   68     68   
        let mut builder = Self::builder();
   69     69   
        #[allow(
   70     70   
            unused_variables,
   71     71   
            unreachable_code,
   72     72   
            clippy::single_match,
   73     73   
            clippy::match_single_binding,
   74     74   
            clippy::diverging_sub_expression
   75     75   
        )]
   76         -
        deserializer.read_struct(&PRICINGDETAIL_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&PRICINGDETAIL_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.count = Some(deser.read_integer(member)?);
   80     80   
                }
   81     81   
                Some(1) => {
   82     82   
                    builder.price = Some(deser.read_double(member)?);
   83     83   
                }
   84     84   
                _ => {}
   85     85   
            }
   86     86   
            Ok(())
   87     87   
        })?;
   88     88   
        Ok(builder.build())
   89     89   
    }
   90     90   
}
          91  +
impl PricingDetail {
          92  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          93  +
    pub fn deserialize_with_response(
          94  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          95  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          96  +
        _status: u16,
          97  +
        _body: &[u8],
          98  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          99  +
        Self::deserialize(deserializer)
         100  +
    }
         101  +
}
   91    102   
impl PricingDetail {
   92    103   
    /// Creates a new builder-style object to manufacture [`PricingDetail`](crate::types::PricingDetail).
   93    104   
    pub fn builder() -> crate::types::builders::PricingDetailBuilder {
   94    105   
        crate::types::builders::PricingDetailBuilder::default()
   95    106   
    }
   96    107   
}
   97    108   
   98    109   
/// A builder for [`PricingDetail`](crate::types::PricingDetail).
   99    110   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  100    111   
#[non_exhaustive]

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

@@ -1,1 +140,148 @@
   19     19   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.statuses.is_none()`.
   20     20   
    pub fn statuses(&self) -> &[crate::types::IdFormat] {
   21     21   
        self.statuses.as_deref().unwrap_or_default()
   22     22   
    }
   23     23   
}
   24     24   
static PRINCIPALIDFORMAT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PrincipalIdFormat", "com.amazonaws.ec2", "PrincipalIdFormat");
   26     26   
static PRINCIPALIDFORMAT_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PrincipalIdFormat$Arn", "com.amazonaws.ec2", "PrincipalIdFormat"),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "arn",
          29  +
    "Arn",
   30     30   
    0,
   31     31   
)
   32     32   
.with_xml_name("arn");
   33     33   
static PRINCIPALIDFORMAT_MEMBER_STATUSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PrincipalIdFormat$Statuses", "com.amazonaws.ec2", "PrincipalIdFormat"),
   35     35   
    ::aws_smithy_schema::ShapeType::List,
   36         -
    "statuses",
          36  +
    "Statuses",
   37     37   
    1,
   38     38   
)
   39     39   
.with_xml_name("statusSet");
   40     40   
static PRINCIPALIDFORMAT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   41     41   
    PRINCIPALIDFORMAT_SCHEMA_ID,
   42     42   
    ::aws_smithy_schema::ShapeType::Structure,
   43     43   
    &[&PRINCIPALIDFORMAT_MEMBER_ARN, &PRINCIPALIDFORMAT_MEMBER_STATUSES],
   44     44   
);
   45     45   
impl PrincipalIdFormat {
   46     46   
    /// The schema for this shape.
   47     47   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PRINCIPALIDFORMAT_SCHEMA;
   48     48   
}
   49     49   
impl ::aws_smithy_schema::serde::SerializableStruct for PrincipalIdFormat {
   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.arn {
   56     56   
            ser.write_string(&PRINCIPALIDFORMAT_MEMBER_ARN, val)?;
   57     57   
        }
   58     58   
        if let Some(ref val) = self.statuses {
   59     59   
            ser.write_list(
   60     60   
                &PRINCIPALIDFORMAT_MEMBER_STATUSES,
   61     61   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   62     62   
                    for item in val {
   63     63   
                        ser.write_struct(crate::types::IdFormat::SCHEMA, item)?;
   64     64   
                    }
   65     65   
                    Ok(())
   66     66   
                },
   67     67   
            )?;
   68     68   
        }
   69     69   
        Ok(())
   70     70   
    }
   71     71   
}
   72     72   
impl PrincipalIdFormat {
   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(&PRINCIPALIDFORMAT_SCHEMA, (), |_, member, deser| {
          86  +
        deserializer.read_struct(&PRINCIPALIDFORMAT_SCHEMA, &mut |member, deser| {
   87     87   
            match member.member_index() {
   88     88   
                Some(0) => {
   89     89   
                    builder.arn = Some(deser.read_string(member)?);
   90     90   
                }
   91     91   
                Some(1) => {
   92     92   
                    builder.statuses = Some({
   93         -
                        let container = if let Some(cap) = deser.container_size() {
   94         -
                            Vec::with_capacity(cap)
   95         -
                        } else {
   96         -
                            Vec::new()
   97         -
                        };
   98         -
                        deser.read_list(member, container, |mut list, deser| {
   99         -
                            list.push(crate::types::IdFormat::deserialize(deser)?);
  100         -
                            Ok(list)
  101         -
                        })?
          93  +
                        let mut container = Vec::new();
          94  +
                        deser.read_list(member, &mut |deser| {
          95  +
                            container.push(crate::types::IdFormat::deserialize(deser)?);
          96  +
                            Ok(())
          97  +
                        })?;
          98  +
                        container
  102     99   
                    });
  103    100   
                }
  104    101   
                _ => {}
  105    102   
            }
  106    103   
            Ok(())
  107    104   
        })?;
  108    105   
        Ok(builder.build())
  109    106   
    }
  110    107   
}
         108  +
impl PrincipalIdFormat {
         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 PrincipalIdFormat {
  112    120   
    /// Creates a new builder-style object to manufacture [`PrincipalIdFormat`](crate::types::PrincipalIdFormat).
  113    121   
    pub fn builder() -> crate::types::builders::PrincipalIdFormatBuilder {
  114    122   
        crate::types::builders::PrincipalIdFormatBuilder::default()
  115    123   
    }
  116    124   
}
  117    125   
  118    126   
/// A builder for [`PrincipalIdFormat`](crate::types::PrincipalIdFormat).
  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/_private_dns_details.rs

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

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

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

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

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

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

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

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

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

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

@@ -4,4 +134,145 @@
   24     24   
    "com.amazonaws.ec2",
   25     25   
    "PrivateIpAddressSpecification",
   26     26   
);
   27     27   
static PRIVATEIPADDRESSSPECIFICATION_MEMBER_PRIMARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.ec2#PrivateIpAddressSpecification$Primary",
   30     30   
        "com.amazonaws.ec2",
   31     31   
        "PrivateIpAddressSpecification",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::Boolean,
   34         -
    "primary",
          34  +
    "Primary",
   35     35   
    0,
   36     36   
)
   37     37   
.with_xml_name("primary");
   38     38   
static PRIVATEIPADDRESSSPECIFICATION_MEMBER_PRIVATE_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.ec2#PrivateIpAddressSpecification$PrivateIpAddress",
   41     41   
        "com.amazonaws.ec2",
   42     42   
        "PrivateIpAddressSpecification",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45         -
    "private_ip_address",
          45  +
    "PrivateIpAddress",
   46     46   
    1,
   47     47   
)
   48     48   
.with_xml_name("privateIpAddress");
   49     49   
static PRIVATEIPADDRESSSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    PRIVATEIPADDRESSSPECIFICATION_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[
   53     53   
        &PRIVATEIPADDRESSSPECIFICATION_MEMBER_PRIMARY,
   54     54   
        &PRIVATEIPADDRESSSPECIFICATION_MEMBER_PRIVATE_IP_ADDRESS,
   55     55   
    ],
   56     56   
);
   57     57   
impl PrivateIpAddressSpecification {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PRIVATEIPADDRESSSPECIFICATION_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for PrivateIpAddressSpecification {
   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.primary {
   68     68   
            ser.write_boolean(&PRIVATEIPADDRESSSPECIFICATION_MEMBER_PRIMARY, *val)?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.private_ip_address {
   71     71   
            ser.write_string(&PRIVATEIPADDRESSSPECIFICATION_MEMBER_PRIVATE_IP_ADDRESS, val)?;
   72     72   
        }
   73     73   
        Ok(())
   74     74   
    }
   75     75   
}
   76     76   
impl PrivateIpAddressSpecification {
   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(&PRIVATEIPADDRESSSPECIFICATION_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&PRIVATEIPADDRESSSPECIFICATION_SCHEMA, &mut |member, deser| {
   91     91   
            match member.member_index() {
   92     92   
                Some(0) => {
   93     93   
                    builder.primary = Some(deser.read_boolean(member)?);
   94     94   
                }
   95     95   
                Some(1) => {
   96     96   
                    builder.private_ip_address = Some(deser.read_string(member)?);
   97     97   
                }
   98     98   
                _ => {}
   99     99   
            }
  100    100   
            Ok(())
  101    101   
        })?;
  102    102   
        Ok(builder.build())
  103    103   
    }
  104    104   
}
         105  +
impl PrivateIpAddressSpecification {
         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 PrivateIpAddressSpecification {
  106    117   
    /// Creates a new builder-style object to manufacture [`PrivateIpAddressSpecification`](crate::types::PrivateIpAddressSpecification).
  107    118   
    pub fn builder() -> crate::types::builders::PrivateIpAddressSpecificationBuilder {
  108    119   
        crate::types::builders::PrivateIpAddressSpecificationBuilder::default()
  109    120   
    }
  110    121   
}
  111    122   
  112    123   
/// A builder for [`PrivateIpAddressSpecification`](crate::types::PrivateIpAddressSpecification).
  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/_processor_info.rs

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

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

@@ -1,1 +120,131 @@
   17     17   
    /// <p>The type of product code.</p>
   18     18   
    pub fn product_code_type(&self) -> ::std::option::Option<&crate::types::ProductCodeValues> {
   19     19   
        self.product_code_type.as_ref()
   20     20   
    }
   21     21   
}
   22     22   
static PRODUCTCODE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ProductCode", "com.amazonaws.ec2", "ProductCode");
   24     24   
static PRODUCTCODE_MEMBER_PRODUCT_CODE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ProductCode$ProductCodeId", "com.amazonaws.ec2", "ProductCode"),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "product_code_id",
          27  +
    "ProductCodeId",
   28     28   
    0,
   29     29   
)
   30     30   
.with_xml_name("productCode");
   31     31   
static PRODUCTCODE_MEMBER_PRODUCT_CODE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ProductCode$ProductCodeType", "com.amazonaws.ec2", "ProductCode"),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "product_code_type",
          34  +
    "ProductCodeType",
   35     35   
    1,
   36     36   
)
   37     37   
.with_xml_name("type");
   38     38   
static PRODUCTCODE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    PRODUCTCODE_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&PRODUCTCODE_MEMBER_PRODUCT_CODE_ID, &PRODUCTCODE_MEMBER_PRODUCT_CODE_TYPE],
   42     42   
);
   43     43   
impl ProductCode {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PRODUCTCODE_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for ProductCode {
   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.product_code_id {
   54     54   
            ser.write_string(&PRODUCTCODE_MEMBER_PRODUCT_CODE_ID, val)?;
   55     55   
        }
   56     56   
        if let Some(ref val) = self.product_code_type {
   57     57   
            ser.write_string(&PRODUCTCODE_MEMBER_PRODUCT_CODE_TYPE, val.as_str())?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl ProductCode {
   63     63   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   64         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   65         -
        deserializer: &mut D,
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   66     66   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        #[allow(unused_variables, unused_mut)]
   68     68   
        let mut builder = Self::builder();
   69     69   
        #[allow(
   70     70   
            unused_variables,
   71     71   
            unreachable_code,
   72     72   
            clippy::single_match,
   73     73   
            clippy::match_single_binding,
   74     74   
            clippy::diverging_sub_expression
   75     75   
        )]
   76         -
        deserializer.read_struct(&PRODUCTCODE_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&PRODUCTCODE_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.product_code_id = Some(deser.read_string(member)?);
   80     80   
                }
   81     81   
                Some(1) => {
   82     82   
                    builder.product_code_type = Some(crate::types::ProductCodeValues::from(deser.read_string(member)?.as_str()));
   83     83   
                }
   84     84   
                _ => {}
   85     85   
            }
   86     86   
            Ok(())
   87     87   
        })?;
   88     88   
        Ok(builder.build())
   89     89   
    }
   90     90   
}
          91  +
impl ProductCode {
          92  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          93  +
    pub fn deserialize_with_response(
          94  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          95  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          96  +
        _status: u16,
          97  +
        _body: &[u8],
          98  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          99  +
        Self::deserialize(deserializer)
         100  +
    }
         101  +
}
   91    102   
impl ProductCode {
   92    103   
    /// Creates a new builder-style object to manufacture [`ProductCode`](crate::types::ProductCode).
   93    104   
    pub fn builder() -> crate::types::builders::ProductCodeBuilder {
   94    105   
        crate::types::builders::ProductCodeBuilder::default()
   95    106   
    }
   96    107   
}
   97    108   
   98    109   
/// A builder for [`ProductCode`](crate::types::ProductCode).
   99    110   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  100    111   
#[non_exhaustive]

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

@@ -1,1 +101,112 @@
   11     11   
    /// <p>The ID of the virtual private gateway.</p>
   12     12   
    pub fn gateway_id(&self) -> ::std::option::Option<&str> {
   13     13   
        self.gateway_id.as_deref()
   14     14   
    }
   15     15   
}
   16     16   
static PROPAGATINGVGW_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PropagatingVgw", "com.amazonaws.ec2", "PropagatingVgw");
   18     18   
static PROPAGATINGVGW_MEMBER_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PropagatingVgw$GatewayId", "com.amazonaws.ec2", "PropagatingVgw"),
   20     20   
    ::aws_smithy_schema::ShapeType::String,
   21         -
    "gateway_id",
          21  +
    "GatewayId",
   22     22   
    0,
   23     23   
)
   24     24   
.with_xml_name("gatewayId");
   25     25   
static PROPAGATINGVGW_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   26     26   
    PROPAGATINGVGW_SCHEMA_ID,
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28     28   
    &[&PROPAGATINGVGW_MEMBER_GATEWAY_ID],
   29     29   
);
   30     30   
impl PropagatingVgw {
   31     31   
    /// The schema for this shape.
   32     32   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PROPAGATINGVGW_SCHEMA;
   33     33   
}
   34     34   
impl ::aws_smithy_schema::serde::SerializableStruct for PropagatingVgw {
   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.gateway_id {
   41     41   
            ser.write_string(&PROPAGATINGVGW_MEMBER_GATEWAY_ID, val)?;
   42     42   
        }
   43     43   
        Ok(())
   44     44   
    }
   45     45   
}
   46     46   
impl PropagatingVgw {
   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(&PROPAGATINGVGW_SCHEMA, (), |_, member, deser| {
          60  +
        deserializer.read_struct(&PROPAGATINGVGW_SCHEMA, &mut |member, deser| {
   61     61   
            match member.member_index() {
   62     62   
                Some(0) => {
   63     63   
                    builder.gateway_id = Some(deser.read_string(member)?);
   64     64   
                }
   65     65   
                _ => {}
   66     66   
            }
   67     67   
            Ok(())
   68     68   
        })?;
   69     69   
        Ok(builder.build())
   70     70   
    }
   71     71   
}
          72  +
impl PropagatingVgw {
          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 PropagatingVgw {
   73     84   
    /// Creates a new builder-style object to manufacture [`PropagatingVgw`](crate::types::PropagatingVgw).
   74     85   
    pub fn builder() -> crate::types::builders::PropagatingVgwBuilder {
   75     86   
        crate::types::builders::PropagatingVgwBuilder::default()
   76     87   
    }
   77     88   
}
   78     89   
   79     90   
/// A builder for [`PropagatingVgw`](crate::types::PropagatingVgw).
   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/_provisioned_bandwidth.rs

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