AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c (ignoring whitespace)

Files changed:

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

@@ -4,4 +134,145 @@
   24     24   
    "com.amazonaws.ec2",
   25     25   
    "InstanceFamilyCreditSpecification",
   26     26   
);
   27     27   
static INSTANCEFAMILYCREDITSPECIFICATION_MEMBER_INSTANCE_FAMILY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.ec2#InstanceFamilyCreditSpecification$InstanceFamily",
   30     30   
        "com.amazonaws.ec2",
   31     31   
        "InstanceFamilyCreditSpecification",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "instance_family",
          34  +
    "InstanceFamily",
   35     35   
    0,
   36     36   
)
   37     37   
.with_xml_name("instanceFamily");
   38     38   
static INSTANCEFAMILYCREDITSPECIFICATION_MEMBER_CPU_CREDITS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.ec2#InstanceFamilyCreditSpecification$CpuCredits",
   41     41   
        "com.amazonaws.ec2",
   42     42   
        "InstanceFamilyCreditSpecification",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45         -
    "cpu_credits",
          45  +
    "CpuCredits",
   46     46   
    1,
   47     47   
)
   48     48   
.with_xml_name("cpuCredits");
   49     49   
static INSTANCEFAMILYCREDITSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    INSTANCEFAMILYCREDITSPECIFICATION_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[
   53     53   
        &INSTANCEFAMILYCREDITSPECIFICATION_MEMBER_INSTANCE_FAMILY,
   54     54   
        &INSTANCEFAMILYCREDITSPECIFICATION_MEMBER_CPU_CREDITS,
   55     55   
    ],
   56     56   
);
   57     57   
impl InstanceFamilyCreditSpecification {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INSTANCEFAMILYCREDITSPECIFICATION_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for InstanceFamilyCreditSpecification {
   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.instance_family {
   68     68   
            ser.write_string(&INSTANCEFAMILYCREDITSPECIFICATION_MEMBER_INSTANCE_FAMILY, val.as_str())?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.cpu_credits {
   71     71   
            ser.write_string(&INSTANCEFAMILYCREDITSPECIFICATION_MEMBER_CPU_CREDITS, val)?;
   72     72   
        }
   73     73   
        Ok(())
   74     74   
    }
   75     75   
}
   76     76   
impl InstanceFamilyCreditSpecification {
   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(&INSTANCEFAMILYCREDITSPECIFICATION_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&INSTANCEFAMILYCREDITSPECIFICATION_SCHEMA, &mut |member, deser| {
   91     91   
            match member.member_index() {
   92     92   
                Some(0) => {
   93     93   
                    builder.instance_family = Some(crate::types::UnlimitedSupportedInstanceFamily::from(deser.read_string(member)?.as_str()));
   94     94   
                }
   95     95   
                Some(1) => {
   96     96   
                    builder.cpu_credits = 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 InstanceFamilyCreditSpecification {
         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 InstanceFamilyCreditSpecification {
  106    117   
    /// Creates a new builder-style object to manufacture [`InstanceFamilyCreditSpecification`](crate::types::InstanceFamilyCreditSpecification).
  107    118   
    pub fn builder() -> crate::types::builders::InstanceFamilyCreditSpecificationBuilder {
  108    119   
        crate::types::builders::InstanceFamilyCreditSpecificationBuilder::default()
  109    120   
    }
  110    121   
}
  111    122   
  112    123   
/// A builder for [`InstanceFamilyCreditSpecification`](crate::types::InstanceFamilyCreditSpecification).
  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/_instance_image_metadata.rs

@@ -51,51 +210,210 @@
   71     71   
}
   72     72   
static INSTANCEIMAGEMETADATA_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   73     73   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#InstanceImageMetadata", "com.amazonaws.ec2", "InstanceImageMetadata");
   74     74   
static INSTANCEIMAGEMETADATA_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "com.amazonaws.ec2#InstanceImageMetadata$InstanceId",
   77     77   
        "com.amazonaws.ec2",
   78     78   
        "InstanceImageMetadata",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "instance_id",
          81  +
    "InstanceId",
   82     82   
    0,
   83     83   
)
   84     84   
.with_xml_name("instanceId");
   85     85   
static INSTANCEIMAGEMETADATA_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "com.amazonaws.ec2#InstanceImageMetadata$InstanceType",
   88     88   
        "com.amazonaws.ec2",
   89     89   
        "InstanceImageMetadata",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::String,
   92         -
    "instance_type",
          92  +
    "InstanceType",
   93     93   
    1,
   94     94   
)
   95     95   
.with_xml_name("instanceType");
   96     96   
static INSTANCEIMAGEMETADATA_MEMBER_LAUNCH_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static(
   98     98   
        "com.amazonaws.ec2#InstanceImageMetadata$LaunchTime",
   99     99   
        "com.amazonaws.ec2",
  100    100   
        "InstanceImageMetadata",
  101    101   
    ),
  102    102   
    ::aws_smithy_schema::ShapeType::Timestamp,
  103         -
    "launch_time",
         103  +
    "LaunchTime",
  104    104   
    2,
  105    105   
)
  106    106   
.with_xml_name("launchTime");
  107    107   
static INSTANCEIMAGEMETADATA_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.ec2#InstanceImageMetadata$AvailabilityZone",
  110    110   
        "com.amazonaws.ec2",
  111    111   
        "InstanceImageMetadata",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::String,
  114         -
    "availability_zone",
         114  +
    "AvailabilityZone",
  115    115   
    3,
  116    116   
)
  117    117   
.with_xml_name("availabilityZone");
  118    118   
static INSTANCEIMAGEMETADATA_MEMBER_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.ec2#InstanceImageMetadata$ZoneId",
  121    121   
        "com.amazonaws.ec2",
  122    122   
        "InstanceImageMetadata",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::String,
  125         -
    "zone_id",
         125  +
    "ZoneId",
  126    126   
    4,
  127    127   
)
  128    128   
.with_xml_name("zoneId");
  129    129   
static INSTANCEIMAGEMETADATA_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static(
  131    131   
        "com.amazonaws.ec2#InstanceImageMetadata$State",
  132    132   
        "com.amazonaws.ec2",
  133    133   
        "InstanceImageMetadata",
  134    134   
    ),
  135    135   
    ::aws_smithy_schema::ShapeType::Structure,
  136         -
    "state",
         136  +
    "State",
  137    137   
    5,
  138    138   
)
  139    139   
.with_xml_name("instanceState");
  140    140   
static INSTANCEIMAGEMETADATA_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static(
  142    142   
        "com.amazonaws.ec2#InstanceImageMetadata$OwnerId",
  143    143   
        "com.amazonaws.ec2",
  144    144   
        "InstanceImageMetadata",
  145    145   
    ),
  146    146   
    ::aws_smithy_schema::ShapeType::String,
  147         -
    "owner_id",
         147  +
    "OwnerId",
  148    148   
    6,
  149    149   
)
  150    150   
.with_xml_name("instanceOwnerId");
  151    151   
static INSTANCEIMAGEMETADATA_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  152    152   
    ::aws_smithy_schema::ShapeId::from_static(
  153    153   
        "com.amazonaws.ec2#InstanceImageMetadata$Tags",
  154    154   
        "com.amazonaws.ec2",
  155    155   
        "InstanceImageMetadata",
  156    156   
    ),
  157    157   
    ::aws_smithy_schema::ShapeType::List,
  158         -
    "tags",
         158  +
    "Tags",
  159    159   
    7,
  160    160   
)
  161    161   
.with_xml_name("tagSet");
  162    162   
static INSTANCEIMAGEMETADATA_MEMBER_IMAGE_METADATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  163    163   
    ::aws_smithy_schema::ShapeId::from_static(
  164    164   
        "com.amazonaws.ec2#InstanceImageMetadata$ImageMetadata",
  165    165   
        "com.amazonaws.ec2",
  166    166   
        "InstanceImageMetadata",
  167    167   
    ),
  168    168   
    ::aws_smithy_schema::ShapeType::Structure,
  169         -
    "image_metadata",
         169  +
    "ImageMetadata",
  170    170   
    8,
  171    171   
)
  172    172   
.with_xml_name("imageMetadata");
  173    173   
static INSTANCEIMAGEMETADATA_MEMBER_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  174    174   
    ::aws_smithy_schema::ShapeId::from_static(
  175    175   
        "com.amazonaws.ec2#InstanceImageMetadata$Operator",
  176    176   
        "com.amazonaws.ec2",
  177    177   
        "InstanceImageMetadata",
  178    178   
    ),
  179    179   
    ::aws_smithy_schema::ShapeType::Structure,
  180         -
    "operator",
         180  +
    "Operator",
  181    181   
    9,
  182    182   
)
  183    183   
.with_xml_name("operator");
  184    184   
static INSTANCEIMAGEMETADATA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  185    185   
    INSTANCEIMAGEMETADATA_SCHEMA_ID,
  186    186   
    ::aws_smithy_schema::ShapeType::Structure,
  187    187   
    &[
  188    188   
        &INSTANCEIMAGEMETADATA_MEMBER_INSTANCE_ID,
  189    189   
        &INSTANCEIMAGEMETADATA_MEMBER_INSTANCE_TYPE,
  190    190   
        &INSTANCEIMAGEMETADATA_MEMBER_LAUNCH_TIME,
@@ -223,223 +343,351 @@
  243    243   
            ser.write_struct(&INSTANCEIMAGEMETADATA_MEMBER_IMAGE_METADATA, val)?;
  244    244   
        }
  245    245   
        if let Some(ref val) = self.operator {
  246    246   
            ser.write_struct(&INSTANCEIMAGEMETADATA_MEMBER_OPERATOR, val)?;
  247    247   
        }
  248    248   
        Ok(())
  249    249   
    }
  250    250   
}
  251    251   
impl InstanceImageMetadata {
  252    252   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  253         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  254         -
        deserializer: &mut D,
         253  +
    pub fn deserialize(
         254  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  255    255   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  256    256   
        #[allow(unused_variables, unused_mut)]
  257    257   
        let mut builder = Self::builder();
  258    258   
        #[allow(
  259    259   
            unused_variables,
  260    260   
            unreachable_code,
  261    261   
            clippy::single_match,
  262    262   
            clippy::match_single_binding,
  263    263   
            clippy::diverging_sub_expression
  264    264   
        )]
  265         -
        deserializer.read_struct(&INSTANCEIMAGEMETADATA_SCHEMA, (), |_, member, deser| {
         265  +
        deserializer.read_struct(&INSTANCEIMAGEMETADATA_SCHEMA, &mut |member, deser| {
  266    266   
            match member.member_index() {
  267    267   
                Some(0) => {
  268    268   
                    builder.instance_id = Some(deser.read_string(member)?);
  269    269   
                }
  270    270   
                Some(1) => {
  271    271   
                    builder.instance_type = Some(crate::types::InstanceType::from(deser.read_string(member)?.as_str()));
  272    272   
                }
  273    273   
                Some(2) => {
  274    274   
                    builder.launch_time = Some(deser.read_timestamp(member)?);
  275    275   
                }
  276    276   
                Some(3) => {
  277    277   
                    builder.availability_zone = Some(deser.read_string(member)?);
  278    278   
                }
  279    279   
                Some(4) => {
  280    280   
                    builder.zone_id = Some(deser.read_string(member)?);
  281    281   
                }
  282    282   
                Some(5) => {
  283    283   
                    builder.state = Some(crate::types::InstanceState::deserialize(deser)?);
  284    284   
                }
  285    285   
                Some(6) => {
  286    286   
                    builder.owner_id = Some(deser.read_string(member)?);
  287    287   
                }
  288    288   
                Some(7) => {
  289    289   
                    builder.tags = Some({
  290         -
                        let container = if let Some(cap) = deser.container_size() {
  291         -
                            Vec::with_capacity(cap)
  292         -
                        } else {
  293         -
                            Vec::new()
  294         -
                        };
  295         -
                        deser.read_list(member, container, |mut list, deser| {
  296         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  297         -
                            Ok(list)
  298         -
                        })?
         290  +
                        let mut container = Vec::new();
         291  +
                        deser.read_list(member, &mut |deser| {
         292  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         293  +
                            Ok(())
         294  +
                        })?;
         295  +
                        container
  299    296   
                    });
  300    297   
                }
  301    298   
                Some(8) => {
  302    299   
                    builder.image_metadata = Some(crate::types::ImageMetadata::deserialize(deser)?);
  303    300   
                }
  304    301   
                Some(9) => {
  305    302   
                    builder.operator = Some(crate::types::OperatorResponse::deserialize(deser)?);
  306    303   
                }
  307    304   
                _ => {}
  308    305   
            }
  309    306   
            Ok(())
  310    307   
        })?;
  311    308   
        Ok(builder.build())
  312    309   
    }
  313    310   
}
         311  +
impl InstanceImageMetadata {
         312  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         313  +
    pub fn deserialize_with_response(
         314  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         315  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         316  +
        _status: u16,
         317  +
        _body: &[u8],
         318  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         319  +
        Self::deserialize(deserializer)
         320  +
    }
         321  +
}
  314    322   
impl InstanceImageMetadata {
  315    323   
    /// Creates a new builder-style object to manufacture [`InstanceImageMetadata`](crate::types::InstanceImageMetadata).
  316    324   
    pub fn builder() -> crate::types::builders::InstanceImageMetadataBuilder {
  317    325   
        crate::types::builders::InstanceImageMetadataBuilder::default()
  318    326   
    }
  319    327   
}
  320    328   
  321    329   
/// A builder for [`InstanceImageMetadata`](crate::types::InstanceImageMetadata).
  322    330   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  323    331   
#[non_exhaustive]

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

@@ -1,1 +105,116 @@
   15     15   
}
   16     16   
static INSTANCEIPV4PREFIX_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#InstanceIpv4Prefix", "com.amazonaws.ec2", "InstanceIpv4Prefix");
   18     18   
static INSTANCEIPV4PREFIX_MEMBER_IPV4_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static(
   20     20   
        "com.amazonaws.ec2#InstanceIpv4Prefix$Ipv4Prefix",
   21     21   
        "com.amazonaws.ec2",
   22     22   
        "InstanceIpv4Prefix",
   23     23   
    ),
   24     24   
    ::aws_smithy_schema::ShapeType::String,
   25         -
    "ipv4_prefix",
          25  +
    "Ipv4Prefix",
   26     26   
    0,
   27     27   
)
   28     28   
.with_xml_name("ipv4Prefix");
   29     29   
static INSTANCEIPV4PREFIX_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   30     30   
    INSTANCEIPV4PREFIX_SCHEMA_ID,
   31     31   
    ::aws_smithy_schema::ShapeType::Structure,
   32     32   
    &[&INSTANCEIPV4PREFIX_MEMBER_IPV4_PREFIX],
   33     33   
);
   34     34   
impl InstanceIpv4Prefix {
   35     35   
    /// The schema for this shape.
   36     36   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INSTANCEIPV4PREFIX_SCHEMA;
   37     37   
}
   38     38   
impl ::aws_smithy_schema::serde::SerializableStruct for InstanceIpv4Prefix {
   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.ipv4_prefix {
   45     45   
            ser.write_string(&INSTANCEIPV4PREFIX_MEMBER_IPV4_PREFIX, val)?;
   46     46   
        }
   47     47   
        Ok(())
   48     48   
    }
   49     49   
}
   50     50   
impl InstanceIpv4Prefix {
   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(&INSTANCEIPV4PREFIX_SCHEMA, (), |_, member, deser| {
          64  +
        deserializer.read_struct(&INSTANCEIPV4PREFIX_SCHEMA, &mut |member, deser| {
   65     65   
            match member.member_index() {
   66     66   
                Some(0) => {
   67     67   
                    builder.ipv4_prefix = 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 InstanceIpv4Prefix {
          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 InstanceIpv4Prefix {
   77     88   
    /// Creates a new builder-style object to manufacture [`InstanceIpv4Prefix`](crate::types::InstanceIpv4Prefix).
   78     89   
    pub fn builder() -> crate::types::builders::InstanceIpv4PrefixBuilder {
   79     90   
        crate::types::builders::InstanceIpv4PrefixBuilder::default()
   80     91   
    }
   81     92   
}
   82     93   
   83     94   
/// A builder for [`InstanceIpv4Prefix`](crate::types::InstanceIpv4Prefix).
   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/_instance_ipv6_address.rs

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

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

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

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

@@ -1,1 +105,116 @@
   15     15   
}
   16     16   
static INSTANCEIPV6PREFIX_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#InstanceIpv6Prefix", "com.amazonaws.ec2", "InstanceIpv6Prefix");
   18     18   
static INSTANCEIPV6PREFIX_MEMBER_IPV6_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static(
   20     20   
        "com.amazonaws.ec2#InstanceIpv6Prefix$Ipv6Prefix",
   21     21   
        "com.amazonaws.ec2",
   22     22   
        "InstanceIpv6Prefix",
   23     23   
    ),
   24     24   
    ::aws_smithy_schema::ShapeType::String,
   25         -
    "ipv6_prefix",
          25  +
    "Ipv6Prefix",
   26     26   
    0,
   27     27   
)
   28     28   
.with_xml_name("ipv6Prefix");
   29     29   
static INSTANCEIPV6PREFIX_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   30     30   
    INSTANCEIPV6PREFIX_SCHEMA_ID,
   31     31   
    ::aws_smithy_schema::ShapeType::Structure,
   32     32   
    &[&INSTANCEIPV6PREFIX_MEMBER_IPV6_PREFIX],
   33     33   
);
   34     34   
impl InstanceIpv6Prefix {
   35     35   
    /// The schema for this shape.
   36     36   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INSTANCEIPV6PREFIX_SCHEMA;
   37     37   
}
   38     38   
impl ::aws_smithy_schema::serde::SerializableStruct for InstanceIpv6Prefix {
   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.ipv6_prefix {
   45     45   
            ser.write_string(&INSTANCEIPV6PREFIX_MEMBER_IPV6_PREFIX, val)?;
   46     46   
        }
   47     47   
        Ok(())
   48     48   
    }
   49     49   
}
   50     50   
impl InstanceIpv6Prefix {
   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(&INSTANCEIPV6PREFIX_SCHEMA, (), |_, member, deser| {
          64  +
        deserializer.read_struct(&INSTANCEIPV6PREFIX_SCHEMA, &mut |member, deser| {
   65     65   
            match member.member_index() {
   66     66   
                Some(0) => {
   67     67   
                    builder.ipv6_prefix = 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 InstanceIpv6Prefix {
          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 InstanceIpv6Prefix {
   77     88   
    /// Creates a new builder-style object to manufacture [`InstanceIpv6Prefix`](crate::types::InstanceIpv6Prefix).
   78     89   
    pub fn builder() -> crate::types::builders::InstanceIpv6PrefixBuilder {
   79     90   
        crate::types::builders::InstanceIpv6PrefixBuilder::default()
   80     91   
    }
   81     92   
}
   82     93   
   83     94   
/// A builder for [`InstanceIpv6Prefix`](crate::types::InstanceIpv6Prefix).
   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/_instance_maintenance_options.rs

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

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

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

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

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

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

@@ -52,52 +254,265 @@
   72     72   
    "com.amazonaws.ec2",
   73     73   
    "InstanceMetadataDefaultsResponse",
   74     74   
);
   75     75   
static INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_HTTP_TOKENS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static(
   77     77   
        "com.amazonaws.ec2#InstanceMetadataDefaultsResponse$HttpTokens",
   78     78   
        "com.amazonaws.ec2",
   79     79   
        "InstanceMetadataDefaultsResponse",
   80     80   
    ),
   81     81   
    ::aws_smithy_schema::ShapeType::String,
   82         -
    "http_tokens",
          82  +
    "HttpTokens",
   83     83   
    0,
   84     84   
)
   85     85   
.with_xml_name("httpTokens");
   86     86   
static INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_HTTP_PUT_RESPONSE_HOP_LIMIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.ec2#InstanceMetadataDefaultsResponse$HttpPutResponseHopLimit",
   89     89   
        "com.amazonaws.ec2",
   90     90   
        "InstanceMetadataDefaultsResponse",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::Integer,
   93         -
    "http_put_response_hop_limit",
          93  +
    "HttpPutResponseHopLimit",
   94     94   
    1,
   95     95   
)
   96     96   
.with_xml_name("httpPutResponseHopLimit");
   97     97   
static INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_HTTP_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.ec2#InstanceMetadataDefaultsResponse$HttpEndpoint",
  100    100   
        "com.amazonaws.ec2",
  101    101   
        "InstanceMetadataDefaultsResponse",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::String,
  104         -
    "http_endpoint",
         104  +
    "HttpEndpoint",
  105    105   
    2,
  106    106   
)
  107    107   
.with_xml_name("httpEndpoint");
  108    108   
static INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_INSTANCE_METADATA_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static(
  110    110   
        "com.amazonaws.ec2#InstanceMetadataDefaultsResponse$InstanceMetadataTags",
  111    111   
        "com.amazonaws.ec2",
  112    112   
        "InstanceMetadataDefaultsResponse",
  113    113   
    ),
  114    114   
    ::aws_smithy_schema::ShapeType::String,
  115         -
    "instance_metadata_tags",
         115  +
    "InstanceMetadataTags",
  116    116   
    3,
  117    117   
)
  118    118   
.with_xml_name("instanceMetadataTags");
  119    119   
static INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_MANAGED_BY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.ec2#InstanceMetadataDefaultsResponse$ManagedBy",
  122    122   
        "com.amazonaws.ec2",
  123    123   
        "InstanceMetadataDefaultsResponse",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::String,
  126         -
    "managed_by",
         126  +
    "ManagedBy",
  127    127   
    4,
  128    128   
)
  129    129   
.with_xml_name("managedBy");
  130    130   
static INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_MANAGED_EXCEPTION_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static(
  132    132   
        "com.amazonaws.ec2#InstanceMetadataDefaultsResponse$ManagedExceptionMessage",
  133    133   
        "com.amazonaws.ec2",
  134    134   
        "InstanceMetadataDefaultsResponse",
  135    135   
    ),
  136    136   
    ::aws_smithy_schema::ShapeType::String,
  137         -
    "managed_exception_message",
         137  +
    "ManagedExceptionMessage",
  138    138   
    5,
  139    139   
)
  140    140   
.with_xml_name("managedExceptionMessage");
  141    141   
static INSTANCEMETADATADEFAULTSRESPONSE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  142    142   
    INSTANCEMETADATADEFAULTSRESPONSE_SCHEMA_ID,
  143    143   
    ::aws_smithy_schema::ShapeType::Structure,
  144    144   
    &[
  145    145   
        &INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_HTTP_TOKENS,
  146    146   
        &INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_HTTP_PUT_RESPONSE_HOP_LIMIT,
  147    147   
        &INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_HTTP_ENDPOINT,
  148    148   
        &INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_INSTANCE_METADATA_TAGS,
  149    149   
        &INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_MANAGED_BY,
  150    150   
        &INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_MANAGED_EXCEPTION_MESSAGE,
  151    151   
    ],
  152    152   
);
  153    153   
impl InstanceMetadataDefaultsResponse {
  154    154   
    /// The schema for this shape.
  155    155   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INSTANCEMETADATADEFAULTSRESPONSE_SCHEMA;
  156    156   
}
  157    157   
impl ::aws_smithy_schema::serde::SerializableStruct for InstanceMetadataDefaultsResponse {
  158    158   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  159    159   
    fn serialize_members(
  160    160   
        &self,
  161    161   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  162    162   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  163    163   
        if let Some(ref val) = self.http_tokens {
  164    164   
            ser.write_string(&INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_HTTP_TOKENS, val.as_str())?;
  165    165   
        }
  166    166   
        if let Some(ref val) = self.http_put_response_hop_limit {
  167    167   
            ser.write_integer(&INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_HTTP_PUT_RESPONSE_HOP_LIMIT, *val)?;
  168    168   
        }
  169    169   
        if let Some(ref val) = self.http_endpoint {
  170    170   
            ser.write_string(&INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_HTTP_ENDPOINT, val.as_str())?;
  171    171   
        }
  172    172   
        if let Some(ref val) = self.instance_metadata_tags {
  173    173   
            ser.write_string(&INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_INSTANCE_METADATA_TAGS, val.as_str())?;
  174    174   
        }
  175    175   
        if let Some(ref val) = self.managed_by {
  176    176   
            ser.write_string(&INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_MANAGED_BY, val.as_str())?;
  177    177   
        }
  178    178   
        if let Some(ref val) = self.managed_exception_message {
  179    179   
            ser.write_string(&INSTANCEMETADATADEFAULTSRESPONSE_MEMBER_MANAGED_EXCEPTION_MESSAGE, val)?;
  180    180   
        }
  181    181   
        Ok(())
  182    182   
    }
  183    183   
}
  184    184   
impl InstanceMetadataDefaultsResponse {
  185    185   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  186         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  187         -
        deserializer: &mut D,
         186  +
    pub fn deserialize(
         187  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  188    188   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  189    189   
        #[allow(unused_variables, unused_mut)]
  190    190   
        let mut builder = Self::builder();
  191    191   
        #[allow(
  192    192   
            unused_variables,
  193    193   
            unreachable_code,
  194    194   
            clippy::single_match,
  195    195   
            clippy::match_single_binding,
  196    196   
            clippy::diverging_sub_expression
  197    197   
        )]
  198         -
        deserializer.read_struct(&INSTANCEMETADATADEFAULTSRESPONSE_SCHEMA, (), |_, member, deser| {
         198  +
        deserializer.read_struct(&INSTANCEMETADATADEFAULTSRESPONSE_SCHEMA, &mut |member, deser| {
  199    199   
            match member.member_index() {
  200    200   
                Some(0) => {
  201    201   
                    builder.http_tokens = Some(crate::types::HttpTokensState::from(deser.read_string(member)?.as_str()));
  202    202   
                }
  203    203   
                Some(1) => {
  204    204   
                    builder.http_put_response_hop_limit = Some(deser.read_integer(member)?);
  205    205   
                }
  206    206   
                Some(2) => {
  207    207   
                    builder.http_endpoint = Some(crate::types::InstanceMetadataEndpointState::from(deser.read_string(member)?.as_str()));
  208    208   
                }
  209    209   
                Some(3) => {
  210    210   
                    builder.instance_metadata_tags = Some(crate::types::InstanceMetadataTagsState::from(deser.read_string(member)?.as_str()));
  211    211   
                }
  212    212   
                Some(4) => {
  213    213   
                    builder.managed_by = Some(crate::types::ManagedBy::from(deser.read_string(member)?.as_str()));
  214    214   
                }
  215    215   
                Some(5) => {
  216    216   
                    builder.managed_exception_message = Some(deser.read_string(member)?);
  217    217   
                }
  218    218   
                _ => {}
  219    219   
            }
  220    220   
            Ok(())
  221    221   
        })?;
  222    222   
        Ok(builder.build())
  223    223   
    }
  224    224   
}
         225  +
impl InstanceMetadataDefaultsResponse {
         226  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         227  +
    pub fn deserialize_with_response(
         228  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         229  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         230  +
        _status: u16,
         231  +
        _body: &[u8],
         232  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         233  +
        Self::deserialize(deserializer)
         234  +
    }
         235  +
}
  225    236   
impl InstanceMetadataDefaultsResponse {
  226    237   
    /// Creates a new builder-style object to manufacture [`InstanceMetadataDefaultsResponse`](crate::types::InstanceMetadataDefaultsResponse).
  227    238   
    pub fn builder() -> crate::types::builders::InstanceMetadataDefaultsResponseBuilder {
  228    239   
        crate::types::builders::InstanceMetadataDefaultsResponseBuilder::default()
  229    240   
    }
  230    241   
}
  231    242   
  232    243   
/// A builder for [`InstanceMetadataDefaultsResponse`](crate::types::InstanceMetadataDefaultsResponse).
  233    244   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  234    245   
#[non_exhaustive]

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

@@ -60,60 +239,250 @@
   80     80   
    "com.amazonaws.ec2",
   81     81   
    "InstanceMetadataOptionsRequest",
   82     82   
);
   83     83   
static INSTANCEMETADATAOPTIONSREQUEST_MEMBER_HTTP_TOKENS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.ec2#InstanceMetadataOptionsRequest$HttpTokens",
   86     86   
        "com.amazonaws.ec2",
   87     87   
        "InstanceMetadataOptionsRequest",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "http_tokens",
          90  +
    "HttpTokens",
   91     91   
    0,
   92     92   
);
   93     93   
static INSTANCEMETADATAOPTIONSREQUEST_MEMBER_HTTP_PUT_RESPONSE_HOP_LIMIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.ec2#InstanceMetadataOptionsRequest$HttpPutResponseHopLimit",
   96     96   
        "com.amazonaws.ec2",
   97     97   
        "InstanceMetadataOptionsRequest",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::Integer,
  100         -
    "http_put_response_hop_limit",
         100  +
    "HttpPutResponseHopLimit",
  101    101   
    1,
  102    102   
);
  103    103   
static INSTANCEMETADATAOPTIONSREQUEST_MEMBER_HTTP_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.ec2#InstanceMetadataOptionsRequest$HttpEndpoint",
  106    106   
        "com.amazonaws.ec2",
  107    107   
        "InstanceMetadataOptionsRequest",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::String,
  110         -
    "http_endpoint",
         110  +
    "HttpEndpoint",
  111    111   
    2,
  112    112   
);
  113    113   
static INSTANCEMETADATAOPTIONSREQUEST_MEMBER_HTTP_PROTOCOL_IPV6: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static(
  115    115   
        "com.amazonaws.ec2#InstanceMetadataOptionsRequest$HttpProtocolIpv6",
  116    116   
        "com.amazonaws.ec2",
  117    117   
        "InstanceMetadataOptionsRequest",
  118    118   
    ),
  119    119   
    ::aws_smithy_schema::ShapeType::String,
  120         -
    "http_protocol_ipv6",
         120  +
    "HttpProtocolIpv6",
  121    121   
    3,
  122    122   
);
  123    123   
static INSTANCEMETADATAOPTIONSREQUEST_MEMBER_INSTANCE_METADATA_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.ec2#InstanceMetadataOptionsRequest$InstanceMetadataTags",
  126    126   
        "com.amazonaws.ec2",
  127    127   
        "InstanceMetadataOptionsRequest",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::String,
  130         -
    "instance_metadata_tags",
         130  +
    "InstanceMetadataTags",
  131    131   
    4,
  132    132   
);
  133    133   
static INSTANCEMETADATAOPTIONSREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  134    134   
    INSTANCEMETADATAOPTIONSREQUEST_SCHEMA_ID,
  135    135   
    ::aws_smithy_schema::ShapeType::Structure,
  136    136   
    &[
  137    137   
        &INSTANCEMETADATAOPTIONSREQUEST_MEMBER_HTTP_TOKENS,
  138    138   
        &INSTANCEMETADATAOPTIONSREQUEST_MEMBER_HTTP_PUT_RESPONSE_HOP_LIMIT,
  139    139   
        &INSTANCEMETADATAOPTIONSREQUEST_MEMBER_HTTP_ENDPOINT,
  140    140   
        &INSTANCEMETADATAOPTIONSREQUEST_MEMBER_HTTP_PROTOCOL_IPV6,
  141    141   
        &INSTANCEMETADATAOPTIONSREQUEST_MEMBER_INSTANCE_METADATA_TAGS,
  142    142   
    ],
  143    143   
);
  144    144   
impl InstanceMetadataOptionsRequest {
  145    145   
    /// The schema for this shape.
  146    146   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INSTANCEMETADATAOPTIONSREQUEST_SCHEMA;
  147    147   
}
  148    148   
impl ::aws_smithy_schema::serde::SerializableStruct for InstanceMetadataOptionsRequest {
  149    149   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  150    150   
    fn serialize_members(
  151    151   
        &self,
  152    152   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  153    153   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  154    154   
        if let Some(ref val) = self.http_tokens {
  155    155   
            ser.write_string(&INSTANCEMETADATAOPTIONSREQUEST_MEMBER_HTTP_TOKENS, val.as_str())?;
  156    156   
        }
  157    157   
        if let Some(ref val) = self.http_put_response_hop_limit {
  158    158   
            ser.write_integer(&INSTANCEMETADATAOPTIONSREQUEST_MEMBER_HTTP_PUT_RESPONSE_HOP_LIMIT, *val)?;
  159    159   
        }
  160    160   
        if let Some(ref val) = self.http_endpoint {
  161    161   
            ser.write_string(&INSTANCEMETADATAOPTIONSREQUEST_MEMBER_HTTP_ENDPOINT, val.as_str())?;
  162    162   
        }
  163    163   
        if let Some(ref val) = self.http_protocol_ipv6 {
  164    164   
            ser.write_string(&INSTANCEMETADATAOPTIONSREQUEST_MEMBER_HTTP_PROTOCOL_IPV6, val.as_str())?;
  165    165   
        }
  166    166   
        if let Some(ref val) = self.instance_metadata_tags {
  167    167   
            ser.write_string(&INSTANCEMETADATAOPTIONSREQUEST_MEMBER_INSTANCE_METADATA_TAGS, val.as_str())?;
  168    168   
        }
  169    169   
        Ok(())
  170    170   
    }
  171    171   
}
  172    172   
impl InstanceMetadataOptionsRequest {
  173    173   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  174         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  175         -
        deserializer: &mut D,
         174  +
    pub fn deserialize(
         175  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  176    176   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  177    177   
        #[allow(unused_variables, unused_mut)]
  178    178   
        let mut builder = Self::builder();
  179    179   
        #[allow(
  180    180   
            unused_variables,
  181    181   
            unreachable_code,
  182    182   
            clippy::single_match,
  183    183   
            clippy::match_single_binding,
  184    184   
            clippy::diverging_sub_expression
  185    185   
        )]
  186         -
        deserializer.read_struct(&INSTANCEMETADATAOPTIONSREQUEST_SCHEMA, (), |_, member, deser| {
         186  +
        deserializer.read_struct(&INSTANCEMETADATAOPTIONSREQUEST_SCHEMA, &mut |member, deser| {
  187    187   
            match member.member_index() {
  188    188   
                Some(0) => {
  189    189   
                    builder.http_tokens = Some(crate::types::HttpTokensState::from(deser.read_string(member)?.as_str()));
  190    190   
                }
  191    191   
                Some(1) => {
  192    192   
                    builder.http_put_response_hop_limit = Some(deser.read_integer(member)?);
  193    193   
                }
  194    194   
                Some(2) => {
  195    195   
                    builder.http_endpoint = Some(crate::types::InstanceMetadataEndpointState::from(deser.read_string(member)?.as_str()));
  196    196   
                }
  197    197   
                Some(3) => {
  198    198   
                    builder.http_protocol_ipv6 = Some(crate::types::InstanceMetadataProtocolState::from(deser.read_string(member)?.as_str()));
  199    199   
                }
  200    200   
                Some(4) => {
  201    201   
                    builder.instance_metadata_tags = Some(crate::types::InstanceMetadataTagsState::from(deser.read_string(member)?.as_str()));
  202    202   
                }
  203    203   
                _ => {}
  204    204   
            }
  205    205   
            Ok(())
  206    206   
        })?;
  207    207   
        Ok(builder.build())
  208    208   
    }
  209    209   
}
         210  +
impl InstanceMetadataOptionsRequest {
         211  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         212  +
    pub fn deserialize_with_response(
         213  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         214  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         215  +
        _status: u16,
         216  +
        _body: &[u8],
         217  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         218  +
        Self::deserialize(deserializer)
         219  +
    }
         220  +
}
  210    221   
impl InstanceMetadataOptionsRequest {
  211    222   
    /// Creates a new builder-style object to manufacture [`InstanceMetadataOptionsRequest`](crate::types::InstanceMetadataOptionsRequest).
  212    223   
    pub fn builder() -> crate::types::builders::InstanceMetadataOptionsRequestBuilder {
  213    224   
        crate::types::builders::InstanceMetadataOptionsRequestBuilder::default()
  214    225   
    }
  215    226   
}
  216    227   
  217    228   
/// A builder for [`InstanceMetadataOptionsRequest`](crate::types::InstanceMetadataOptionsRequest).
  218    229   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  219    230   
#[non_exhaustive]

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

@@ -50,50 +252,263 @@
   70     70   
    "com.amazonaws.ec2",
   71     71   
    "InstanceMetadataOptionsResponse",
   72     72   
);
   73     73   
static INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.ec2#InstanceMetadataOptionsResponse$State",
   76     76   
        "com.amazonaws.ec2",
   77     77   
        "InstanceMetadataOptionsResponse",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "state",
          80  +
    "State",
   81     81   
    0,
   82     82   
)
   83     83   
.with_xml_name("state");
   84     84   
static INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_HTTP_TOKENS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "com.amazonaws.ec2#InstanceMetadataOptionsResponse$HttpTokens",
   87     87   
        "com.amazonaws.ec2",
   88     88   
        "InstanceMetadataOptionsResponse",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::String,
   91         -
    "http_tokens",
          91  +
    "HttpTokens",
   92     92   
    1,
   93     93   
)
   94     94   
.with_xml_name("httpTokens");
   95     95   
static INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_HTTP_PUT_RESPONSE_HOP_LIMIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.ec2#InstanceMetadataOptionsResponse$HttpPutResponseHopLimit",
   98     98   
        "com.amazonaws.ec2",
   99     99   
        "InstanceMetadataOptionsResponse",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::Integer,
  102         -
    "http_put_response_hop_limit",
         102  +
    "HttpPutResponseHopLimit",
  103    103   
    2,
  104    104   
)
  105    105   
.with_xml_name("httpPutResponseHopLimit");
  106    106   
static INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_HTTP_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.ec2#InstanceMetadataOptionsResponse$HttpEndpoint",
  109    109   
        "com.amazonaws.ec2",
  110    110   
        "InstanceMetadataOptionsResponse",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::String,
  113         -
    "http_endpoint",
         113  +
    "HttpEndpoint",
  114    114   
    3,
  115    115   
)
  116    116   
.with_xml_name("httpEndpoint");
  117    117   
static INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_HTTP_PROTOCOL_IPV6: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.ec2#InstanceMetadataOptionsResponse$HttpProtocolIpv6",
  120    120   
        "com.amazonaws.ec2",
  121    121   
        "InstanceMetadataOptionsResponse",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::String,
  124         -
    "http_protocol_ipv6",
         124  +
    "HttpProtocolIpv6",
  125    125   
    4,
  126    126   
)
  127    127   
.with_xml_name("httpProtocolIpv6");
  128    128   
static INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_INSTANCE_METADATA_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static(
  130    130   
        "com.amazonaws.ec2#InstanceMetadataOptionsResponse$InstanceMetadataTags",
  131    131   
        "com.amazonaws.ec2",
  132    132   
        "InstanceMetadataOptionsResponse",
  133    133   
    ),
  134    134   
    ::aws_smithy_schema::ShapeType::String,
  135         -
    "instance_metadata_tags",
         135  +
    "InstanceMetadataTags",
  136    136   
    5,
  137    137   
)
  138    138   
.with_xml_name("instanceMetadataTags");
  139    139   
static INSTANCEMETADATAOPTIONSRESPONSE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  140    140   
    INSTANCEMETADATAOPTIONSRESPONSE_SCHEMA_ID,
  141    141   
    ::aws_smithy_schema::ShapeType::Structure,
  142    142   
    &[
  143    143   
        &INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_STATE,
  144    144   
        &INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_HTTP_TOKENS,
  145    145   
        &INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_HTTP_PUT_RESPONSE_HOP_LIMIT,
  146    146   
        &INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_HTTP_ENDPOINT,
  147    147   
        &INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_HTTP_PROTOCOL_IPV6,
  148    148   
        &INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_INSTANCE_METADATA_TAGS,
  149    149   
    ],
  150    150   
);
  151    151   
impl InstanceMetadataOptionsResponse {
  152    152   
    /// The schema for this shape.
  153    153   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INSTANCEMETADATAOPTIONSRESPONSE_SCHEMA;
  154    154   
}
  155    155   
impl ::aws_smithy_schema::serde::SerializableStruct for InstanceMetadataOptionsResponse {
  156    156   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  157    157   
    fn serialize_members(
  158    158   
        &self,
  159    159   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  160    160   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  161    161   
        if let Some(ref val) = self.state {
  162    162   
            ser.write_string(&INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_STATE, val.as_str())?;
  163    163   
        }
  164    164   
        if let Some(ref val) = self.http_tokens {
  165    165   
            ser.write_string(&INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_HTTP_TOKENS, val.as_str())?;
  166    166   
        }
  167    167   
        if let Some(ref val) = self.http_put_response_hop_limit {
  168    168   
            ser.write_integer(&INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_HTTP_PUT_RESPONSE_HOP_LIMIT, *val)?;
  169    169   
        }
  170    170   
        if let Some(ref val) = self.http_endpoint {
  171    171   
            ser.write_string(&INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_HTTP_ENDPOINT, val.as_str())?;
  172    172   
        }
  173    173   
        if let Some(ref val) = self.http_protocol_ipv6 {
  174    174   
            ser.write_string(&INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_HTTP_PROTOCOL_IPV6, val.as_str())?;
  175    175   
        }
  176    176   
        if let Some(ref val) = self.instance_metadata_tags {
  177    177   
            ser.write_string(&INSTANCEMETADATAOPTIONSRESPONSE_MEMBER_INSTANCE_METADATA_TAGS, val.as_str())?;
  178    178   
        }
  179    179   
        Ok(())
  180    180   
    }
  181    181   
}
  182    182   
impl InstanceMetadataOptionsResponse {
  183    183   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  184         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  185         -
        deserializer: &mut D,
         184  +
    pub fn deserialize(
         185  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  186    186   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  187    187   
        #[allow(unused_variables, unused_mut)]
  188    188   
        let mut builder = Self::builder();
  189    189   
        #[allow(
  190    190   
            unused_variables,
  191    191   
            unreachable_code,
  192    192   
            clippy::single_match,
  193    193   
            clippy::match_single_binding,
  194    194   
            clippy::diverging_sub_expression
  195    195   
        )]
  196         -
        deserializer.read_struct(&INSTANCEMETADATAOPTIONSRESPONSE_SCHEMA, (), |_, member, deser| {
         196  +
        deserializer.read_struct(&INSTANCEMETADATAOPTIONSRESPONSE_SCHEMA, &mut |member, deser| {
  197    197   
            match member.member_index() {
  198    198   
                Some(0) => {
  199    199   
                    builder.state = Some(crate::types::InstanceMetadataOptionsState::from(deser.read_string(member)?.as_str()));
  200    200   
                }
  201    201   
                Some(1) => {
  202    202   
                    builder.http_tokens = Some(crate::types::HttpTokensState::from(deser.read_string(member)?.as_str()));
  203    203   
                }
  204    204   
                Some(2) => {
  205    205   
                    builder.http_put_response_hop_limit = Some(deser.read_integer(member)?);
  206    206   
                }
  207    207   
                Some(3) => {
  208    208   
                    builder.http_endpoint = Some(crate::types::InstanceMetadataEndpointState::from(deser.read_string(member)?.as_str()));
  209    209   
                }
  210    210   
                Some(4) => {
  211    211   
                    builder.http_protocol_ipv6 = Some(crate::types::InstanceMetadataProtocolState::from(deser.read_string(member)?.as_str()));
  212    212   
                }
  213    213   
                Some(5) => {
  214    214   
                    builder.instance_metadata_tags = Some(crate::types::InstanceMetadataTagsState::from(deser.read_string(member)?.as_str()));
  215    215   
                }
  216    216   
                _ => {}
  217    217   
            }
  218    218   
            Ok(())
  219    219   
        })?;
  220    220   
        Ok(builder.build())
  221    221   
    }
  222    222   
}
         223  +
impl InstanceMetadataOptionsResponse {
         224  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         225  +
    pub fn deserialize_with_response(
         226  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         227  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         228  +
        _status: u16,
         229  +
        _body: &[u8],
         230  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         231  +
        Self::deserialize(deserializer)
         232  +
    }
         233  +
}
  223    234   
impl InstanceMetadataOptionsResponse {
  224    235   
    /// Creates a new builder-style object to manufacture [`InstanceMetadataOptionsResponse`](crate::types::InstanceMetadataOptionsResponse).
  225    236   
    pub fn builder() -> crate::types::builders::InstanceMetadataOptionsResponseBuilder {
  226    237   
        crate::types::builders::InstanceMetadataOptionsResponseBuilder::default()
  227    238   
    }
  228    239   
}
  229    240   
  230    241   
/// A builder for [`InstanceMetadataOptionsResponse`](crate::types::InstanceMetadataOptionsResponse).
  231    242   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  232    243   
#[non_exhaustive]

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

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

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

@@ -124,124 +393,393 @@
  144    144   
    "com.amazonaws.ec2",
  145    145   
    "InstanceNetworkInterface",
  146    146   
);
  147    147   
static INSTANCENETWORKINTERFACE_MEMBER_ASSOCIATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  148    148   
    ::aws_smithy_schema::ShapeId::from_static(
  149    149   
        "com.amazonaws.ec2#InstanceNetworkInterface$Association",
  150    150   
        "com.amazonaws.ec2",
  151    151   
        "InstanceNetworkInterface",
  152    152   
    ),
  153    153   
    ::aws_smithy_schema::ShapeType::Structure,
  154         -
    "association",
         154  +
    "Association",
  155    155   
    0,
  156    156   
)
  157    157   
.with_xml_name("association");
  158    158   
static INSTANCENETWORKINTERFACE_MEMBER_ATTACHMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  159    159   
    ::aws_smithy_schema::ShapeId::from_static(
  160    160   
        "com.amazonaws.ec2#InstanceNetworkInterface$Attachment",
  161    161   
        "com.amazonaws.ec2",
  162    162   
        "InstanceNetworkInterface",
  163    163   
    ),
  164    164   
    ::aws_smithy_schema::ShapeType::Structure,
  165         -
    "attachment",
         165  +
    "Attachment",
  166    166   
    1,
  167    167   
)
  168    168   
.with_xml_name("attachment");
  169    169   
static INSTANCENETWORKINTERFACE_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  170    170   
    ::aws_smithy_schema::ShapeId::from_static(
  171    171   
        "com.amazonaws.ec2#InstanceNetworkInterface$Description",
  172    172   
        "com.amazonaws.ec2",
  173    173   
        "InstanceNetworkInterface",
  174    174   
    ),
  175    175   
    ::aws_smithy_schema::ShapeType::String,
  176         -
    "description",
         176  +
    "Description",
  177    177   
    2,
  178    178   
)
  179    179   
.with_xml_name("description");
  180    180   
static INSTANCENETWORKINTERFACE_MEMBER_GROUPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  181    181   
    ::aws_smithy_schema::ShapeId::from_static(
  182    182   
        "com.amazonaws.ec2#InstanceNetworkInterface$Groups",
  183    183   
        "com.amazonaws.ec2",
  184    184   
        "InstanceNetworkInterface",
  185    185   
    ),
  186    186   
    ::aws_smithy_schema::ShapeType::List,
  187         -
    "groups",
         187  +
    "Groups",
  188    188   
    3,
  189    189   
)
  190    190   
.with_xml_name("groupSet");
  191    191   
static INSTANCENETWORKINTERFACE_MEMBER_IPV6_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  192    192   
    ::aws_smithy_schema::ShapeId::from_static(
  193    193   
        "com.amazonaws.ec2#InstanceNetworkInterface$Ipv6Addresses",
  194    194   
        "com.amazonaws.ec2",
  195    195   
        "InstanceNetworkInterface",
  196    196   
    ),
  197    197   
    ::aws_smithy_schema::ShapeType::List,
  198         -
    "ipv6_addresses",
         198  +
    "Ipv6Addresses",
  199    199   
    4,
  200    200   
)
  201    201   
.with_xml_name("ipv6AddressesSet");
  202    202   
static INSTANCENETWORKINTERFACE_MEMBER_MAC_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  203    203   
    ::aws_smithy_schema::ShapeId::from_static(
  204    204   
        "com.amazonaws.ec2#InstanceNetworkInterface$MacAddress",
  205    205   
        "com.amazonaws.ec2",
  206    206   
        "InstanceNetworkInterface",
  207    207   
    ),
  208    208   
    ::aws_smithy_schema::ShapeType::String,
  209         -
    "mac_address",
         209  +
    "MacAddress",
  210    210   
    5,
  211    211   
)
  212    212   
.with_xml_name("macAddress");
  213    213   
static INSTANCENETWORKINTERFACE_MEMBER_NETWORK_INTERFACE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  214    214   
    ::aws_smithy_schema::ShapeId::from_static(
  215    215   
        "com.amazonaws.ec2#InstanceNetworkInterface$NetworkInterfaceId",
  216    216   
        "com.amazonaws.ec2",
  217    217   
        "InstanceNetworkInterface",
  218    218   
    ),
  219    219   
    ::aws_smithy_schema::ShapeType::String,
  220         -
    "network_interface_id",
         220  +
    "NetworkInterfaceId",
  221    221   
    6,
  222    222   
)
  223    223   
.with_xml_name("networkInterfaceId");
  224    224   
static INSTANCENETWORKINTERFACE_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  225    225   
    ::aws_smithy_schema::ShapeId::from_static(
  226    226   
        "com.amazonaws.ec2#InstanceNetworkInterface$OwnerId",
  227    227   
        "com.amazonaws.ec2",
  228    228   
        "InstanceNetworkInterface",
  229    229   
    ),
  230    230   
    ::aws_smithy_schema::ShapeType::String,
  231         -
    "owner_id",
         231  +
    "OwnerId",
  232    232   
    7,
  233    233   
)
  234    234   
.with_xml_name("ownerId");
  235    235   
static INSTANCENETWORKINTERFACE_MEMBER_PRIVATE_DNS_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  236    236   
    ::aws_smithy_schema::ShapeId::from_static(
  237    237   
        "com.amazonaws.ec2#InstanceNetworkInterface$PrivateDnsName",
  238    238   
        "com.amazonaws.ec2",
  239    239   
        "InstanceNetworkInterface",
  240    240   
    ),
  241    241   
    ::aws_smithy_schema::ShapeType::String,
  242         -
    "private_dns_name",
         242  +
    "PrivateDnsName",
  243    243   
    8,
  244    244   
)
  245    245   
.with_xml_name("privateDnsName");
  246    246   
static INSTANCENETWORKINTERFACE_MEMBER_PRIVATE_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  247    247   
    ::aws_smithy_schema::ShapeId::from_static(
  248    248   
        "com.amazonaws.ec2#InstanceNetworkInterface$PrivateIpAddress",
  249    249   
        "com.amazonaws.ec2",
  250    250   
        "InstanceNetworkInterface",
  251    251   
    ),
  252    252   
    ::aws_smithy_schema::ShapeType::String,
  253         -
    "private_ip_address",
         253  +
    "PrivateIpAddress",
  254    254   
    9,
  255    255   
)
  256    256   
.with_xml_name("privateIpAddress");
  257    257   
static INSTANCENETWORKINTERFACE_MEMBER_PRIVATE_IP_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  258    258   
    ::aws_smithy_schema::ShapeId::from_static(
  259    259   
        "com.amazonaws.ec2#InstanceNetworkInterface$PrivateIpAddresses",
  260    260   
        "com.amazonaws.ec2",
  261    261   
        "InstanceNetworkInterface",
  262    262   
    ),
  263    263   
    ::aws_smithy_schema::ShapeType::List,
  264         -
    "private_ip_addresses",
         264  +
    "PrivateIpAddresses",
  265    265   
    10,
  266    266   
)
  267    267   
.with_xml_name("privateIpAddressesSet");
  268    268   
static INSTANCENETWORKINTERFACE_MEMBER_SOURCE_DEST_CHECK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  269    269   
    ::aws_smithy_schema::ShapeId::from_static(
  270    270   
        "com.amazonaws.ec2#InstanceNetworkInterface$SourceDestCheck",
  271    271   
        "com.amazonaws.ec2",
  272    272   
        "InstanceNetworkInterface",
  273    273   
    ),
  274    274   
    ::aws_smithy_schema::ShapeType::Boolean,
  275         -
    "source_dest_check",
         275  +
    "SourceDestCheck",
  276    276   
    11,
  277    277   
)
  278    278   
.with_xml_name("sourceDestCheck");
  279    279   
static INSTANCENETWORKINTERFACE_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  280    280   
    ::aws_smithy_schema::ShapeId::from_static(
  281    281   
        "com.amazonaws.ec2#InstanceNetworkInterface$Status",
  282    282   
        "com.amazonaws.ec2",
  283    283   
        "InstanceNetworkInterface",
  284    284   
    ),
  285    285   
    ::aws_smithy_schema::ShapeType::String,
  286         -
    "status",
         286  +
    "Status",
  287    287   
    12,
  288    288   
)
  289    289   
.with_xml_name("status");
  290    290   
static INSTANCENETWORKINTERFACE_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  291    291   
    ::aws_smithy_schema::ShapeId::from_static(
  292    292   
        "com.amazonaws.ec2#InstanceNetworkInterface$SubnetId",
  293    293   
        "com.amazonaws.ec2",
  294    294   
        "InstanceNetworkInterface",
  295    295   
    ),
  296    296   
    ::aws_smithy_schema::ShapeType::String,
  297         -
    "subnet_id",
         297  +
    "SubnetId",
  298    298   
    13,
  299    299   
)
  300    300   
.with_xml_name("subnetId");
  301    301   
static INSTANCENETWORKINTERFACE_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  302    302   
    ::aws_smithy_schema::ShapeId::from_static(
  303    303   
        "com.amazonaws.ec2#InstanceNetworkInterface$VpcId",
  304    304   
        "com.amazonaws.ec2",
  305    305   
        "InstanceNetworkInterface",
  306    306   
    ),
  307    307   
    ::aws_smithy_schema::ShapeType::String,
  308         -
    "vpc_id",
         308  +
    "VpcId",
  309    309   
    14,
  310    310   
)
  311    311   
.with_xml_name("vpcId");
  312    312   
static INSTANCENETWORKINTERFACE_MEMBER_INTERFACE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  313    313   
    ::aws_smithy_schema::ShapeId::from_static(
  314    314   
        "com.amazonaws.ec2#InstanceNetworkInterface$InterfaceType",
  315    315   
        "com.amazonaws.ec2",
  316    316   
        "InstanceNetworkInterface",
  317    317   
    ),
  318    318   
    ::aws_smithy_schema::ShapeType::String,
  319         -
    "interface_type",
         319  +
    "InterfaceType",
  320    320   
    15,
  321    321   
)
  322    322   
.with_xml_name("interfaceType");
  323    323   
static INSTANCENETWORKINTERFACE_MEMBER_IPV4_PREFIXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  324    324   
    ::aws_smithy_schema::ShapeId::from_static(
  325    325   
        "com.amazonaws.ec2#InstanceNetworkInterface$Ipv4Prefixes",
  326    326   
        "com.amazonaws.ec2",
  327    327   
        "InstanceNetworkInterface",
  328    328   
    ),
  329    329   
    ::aws_smithy_schema::ShapeType::List,
  330         -
    "ipv4_prefixes",
         330  +
    "Ipv4Prefixes",
  331    331   
    16,
  332    332   
)
  333    333   
.with_xml_name("ipv4PrefixSet");
  334    334   
static INSTANCENETWORKINTERFACE_MEMBER_IPV6_PREFIXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  335    335   
    ::aws_smithy_schema::ShapeId::from_static(
  336    336   
        "com.amazonaws.ec2#InstanceNetworkInterface$Ipv6Prefixes",
  337    337   
        "com.amazonaws.ec2",
  338    338   
        "InstanceNetworkInterface",
  339    339   
    ),
  340    340   
    ::aws_smithy_schema::ShapeType::List,
  341         -
    "ipv6_prefixes",
         341  +
    "Ipv6Prefixes",
  342    342   
    17,
  343    343   
)
  344    344   
.with_xml_name("ipv6PrefixSet");
  345    345   
static INSTANCENETWORKINTERFACE_MEMBER_CONNECTION_TRACKING_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  346    346   
    ::aws_smithy_schema::ShapeId::from_static(
  347    347   
        "com.amazonaws.ec2#InstanceNetworkInterface$ConnectionTrackingConfiguration",
  348    348   
        "com.amazonaws.ec2",
  349    349   
        "InstanceNetworkInterface",
  350    350   
    ),
  351    351   
    ::aws_smithy_schema::ShapeType::Structure,
  352         -
    "connection_tracking_configuration",
         352  +
    "ConnectionTrackingConfiguration",
  353    353   
    18,
  354    354   
)
  355    355   
.with_xml_name("connectionTrackingConfiguration");
  356    356   
static INSTANCENETWORKINTERFACE_MEMBER_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  357    357   
    ::aws_smithy_schema::ShapeId::from_static(
  358    358   
        "com.amazonaws.ec2#InstanceNetworkInterface$Operator",
  359    359   
        "com.amazonaws.ec2",
  360    360   
        "InstanceNetworkInterface",
  361    361   
    ),
  362    362   
    ::aws_smithy_schema::ShapeType::Structure,
  363         -
    "operator",
         363  +
    "Operator",
  364    364   
    19,
  365    365   
)
  366    366   
.with_xml_name("operator");
  367    367   
static INSTANCENETWORKINTERFACE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  368    368   
    INSTANCENETWORKINTERFACE_SCHEMA_ID,
  369    369   
    ::aws_smithy_schema::ShapeType::Structure,
  370    370   
    &[
  371    371   
        &INSTANCENETWORKINTERFACE_MEMBER_ASSOCIATION,
  372    372   
        &INSTANCENETWORKINTERFACE_MEMBER_ATTACHMENT,
  373    373   
        &INSTANCENETWORKINTERFACE_MEMBER_DESCRIPTION,
@@ -478,478 +668,664 @@
  498    498   
            ser.write_struct(&INSTANCENETWORKINTERFACE_MEMBER_CONNECTION_TRACKING_CONFIGURATION, val)?;
  499    499   
        }
  500    500   
        if let Some(ref val) = self.operator {
  501    501   
            ser.write_struct(&INSTANCENETWORKINTERFACE_MEMBER_OPERATOR, val)?;
  502    502   
        }
  503    503   
        Ok(())
  504    504   
    }
  505    505   
}
  506    506   
impl InstanceNetworkInterface {
  507    507   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  508         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  509         -
        deserializer: &mut D,
         508  +
    pub fn deserialize(
         509  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  510    510   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  511    511   
        #[allow(unused_variables, unused_mut)]
  512    512   
        let mut builder = Self::builder();
  513    513   
        #[allow(
  514    514   
            unused_variables,
  515    515   
            unreachable_code,
  516    516   
            clippy::single_match,
  517    517   
            clippy::match_single_binding,
  518    518   
            clippy::diverging_sub_expression
  519    519   
        )]
  520         -
        deserializer.read_struct(&INSTANCENETWORKINTERFACE_SCHEMA, (), |_, member, deser| {
         520  +
        deserializer.read_struct(&INSTANCENETWORKINTERFACE_SCHEMA, &mut |member, deser| {
  521    521   
            match member.member_index() {
  522    522   
                Some(0) => {
  523    523   
                    builder.association = Some(crate::types::InstanceNetworkInterfaceAssociation::deserialize(deser)?);
  524    524   
                }
  525    525   
                Some(1) => {
  526    526   
                    builder.attachment = Some(crate::types::InstanceNetworkInterfaceAttachment::deserialize(deser)?);
  527    527   
                }
  528    528   
                Some(2) => {
  529    529   
                    builder.description = Some(deser.read_string(member)?);
  530    530   
                }
  531    531   
                Some(3) => {
  532    532   
                    builder.groups = Some({
  533         -
                        let container = if let Some(cap) = deser.container_size() {
  534         -
                            Vec::with_capacity(cap)
  535         -
                        } else {
  536         -
                            Vec::new()
  537         -
                        };
  538         -
                        deser.read_list(member, container, |mut list, deser| {
  539         -
                            list.push(crate::types::GroupIdentifier::deserialize(deser)?);
  540         -
                            Ok(list)
  541         -
                        })?
         533  +
                        let mut container = Vec::new();
         534  +
                        deser.read_list(member, &mut |deser| {
         535  +
                            container.push(crate::types::GroupIdentifier::deserialize(deser)?);
         536  +
                            Ok(())
         537  +
                        })?;
         538  +
                        container
  542    539   
                    });
  543    540   
                }
  544    541   
                Some(4) => {
  545    542   
                    builder.ipv6_addresses = Some({
  546         -
                        let container = if let Some(cap) = deser.container_size() {
  547         -
                            Vec::with_capacity(cap)
  548         -
                        } else {
  549         -
                            Vec::new()
  550         -
                        };
  551         -
                        deser.read_list(member, container, |mut list, deser| {
  552         -
                            list.push(crate::types::InstanceIpv6Address::deserialize(deser)?);
  553         -
                            Ok(list)
  554         -
                        })?
         543  +
                        let mut container = Vec::new();
         544  +
                        deser.read_list(member, &mut |deser| {
         545  +
                            container.push(crate::types::InstanceIpv6Address::deserialize(deser)?);
         546  +
                            Ok(())
         547  +
                        })?;
         548  +
                        container
  555    549   
                    });
  556    550   
                }
  557    551   
                Some(5) => {
  558    552   
                    builder.mac_address = Some(deser.read_string(member)?);
  559    553   
                }
  560    554   
                Some(6) => {
  561    555   
                    builder.network_interface_id = Some(deser.read_string(member)?);
  562    556   
                }
  563    557   
                Some(7) => {
  564    558   
                    builder.owner_id = Some(deser.read_string(member)?);
  565    559   
                }
  566    560   
                Some(8) => {
  567    561   
                    builder.private_dns_name = Some(deser.read_string(member)?);
  568    562   
                }
  569    563   
                Some(9) => {
  570    564   
                    builder.private_ip_address = Some(deser.read_string(member)?);
  571    565   
                }
  572    566   
                Some(10) => {
  573    567   
                    builder.private_ip_addresses = Some({
  574         -
                        let container = if let Some(cap) = deser.container_size() {
  575         -
                            Vec::with_capacity(cap)
  576         -
                        } else {
  577         -
                            Vec::new()
  578         -
                        };
  579         -
                        deser.read_list(member, container, |mut list, deser| {
  580         -
                            list.push(crate::types::InstancePrivateIpAddress::deserialize(deser)?);
  581         -
                            Ok(list)
  582         -
                        })?
         568  +
                        let mut container = Vec::new();
         569  +
                        deser.read_list(member, &mut |deser| {
         570  +
                            container.push(crate::types::InstancePrivateIpAddress::deserialize(deser)?);
         571  +
                            Ok(())
         572  +
                        })?;
         573  +
                        container
  583    574   
                    });
  584    575   
                }
  585    576   
                Some(11) => {
  586    577   
                    builder.source_dest_check = Some(deser.read_boolean(member)?);
  587    578   
                }
  588    579   
                Some(12) => {
  589    580   
                    builder.status = Some(crate::types::NetworkInterfaceStatus::from(deser.read_string(member)?.as_str()));
  590    581   
                }
  591    582   
                Some(13) => {
  592    583   
                    builder.subnet_id = Some(deser.read_string(member)?);
  593    584   
                }
  594    585   
                Some(14) => {
  595    586   
                    builder.vpc_id = Some(deser.read_string(member)?);
  596    587   
                }
  597    588   
                Some(15) => {
  598    589   
                    builder.interface_type = Some(deser.read_string(member)?);
  599    590   
                }
  600    591   
                Some(16) => {
  601    592   
                    builder.ipv4_prefixes = Some({
  602         -
                        let container = if let Some(cap) = deser.container_size() {
  603         -
                            Vec::with_capacity(cap)
  604         -
                        } else {
  605         -
                            Vec::new()
  606         -
                        };
  607         -
                        deser.read_list(member, container, |mut list, deser| {
  608         -
                            list.push(crate::types::InstanceIpv4Prefix::deserialize(deser)?);
  609         -
                            Ok(list)
  610         -
                        })?
         593  +
                        let mut container = Vec::new();
         594  +
                        deser.read_list(member, &mut |deser| {
         595  +
                            container.push(crate::types::InstanceIpv4Prefix::deserialize(deser)?);
         596  +
                            Ok(())
         597  +
                        })?;
         598  +
                        container
  611    599   
                    });
  612    600   
                }
  613    601   
                Some(17) => {
  614    602   
                    builder.ipv6_prefixes = Some({
  615         -
                        let container = if let Some(cap) = deser.container_size() {
  616         -
                            Vec::with_capacity(cap)
  617         -
                        } else {
  618         -
                            Vec::new()
  619         -
                        };
  620         -
                        deser.read_list(member, container, |mut list, deser| {
  621         -
                            list.push(crate::types::InstanceIpv6Prefix::deserialize(deser)?);
  622         -
                            Ok(list)
  623         -
                        })?
         603  +
                        let mut container = Vec::new();
         604  +
                        deser.read_list(member, &mut |deser| {
         605  +
                            container.push(crate::types::InstanceIpv6Prefix::deserialize(deser)?);
         606  +
                            Ok(())
         607  +
                        })?;
         608  +
                        container
  624    609   
                    });
  625    610   
                }
  626    611   
                Some(18) => {
  627    612   
                    builder.connection_tracking_configuration = Some(crate::types::ConnectionTrackingSpecificationResponse::deserialize(deser)?);
  628    613   
                }
  629    614   
                Some(19) => {
  630    615   
                    builder.operator = Some(crate::types::OperatorResponse::deserialize(deser)?);
  631    616   
                }
  632    617   
                _ => {}
  633    618   
            }
  634    619   
            Ok(())
  635    620   
        })?;
  636    621   
        Ok(builder.build())
  637    622   
    }
  638    623   
}
         624  +
impl InstanceNetworkInterface {
         625  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         626  +
    pub fn deserialize_with_response(
         627  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         628  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         629  +
        _status: u16,
         630  +
        _body: &[u8],
         631  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         632  +
        Self::deserialize(deserializer)
         633  +
    }
         634  +
}
  639    635   
impl InstanceNetworkInterface {
  640    636   
    /// Creates a new builder-style object to manufacture [`InstanceNetworkInterface`](crate::types::InstanceNetworkInterface).
  641    637   
    pub fn builder() -> crate::types::builders::InstanceNetworkInterfaceBuilder {
  642    638   
        crate::types::builders::InstanceNetworkInterfaceBuilder::default()
  643    639   
    }
  644    640   
}
  645    641   
  646    642   
/// A builder for [`InstanceNetworkInterface`](crate::types::InstanceNetworkInterface).
  647    643   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  648    644   
#[non_exhaustive]

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

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

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

@@ -40,40 +278,289 @@
   60     60   
    "com.amazonaws.ec2",
   61     61   
    "InstanceNetworkInterfaceAttachment",
   62     62   
);
   63     63   
static INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_ATTACH_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.ec2#InstanceNetworkInterfaceAttachment$AttachTime",
   66     66   
        "com.amazonaws.ec2",
   67     67   
        "InstanceNetworkInterfaceAttachment",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::Timestamp,
   70         -
    "attach_time",
          70  +
    "AttachTime",
   71     71   
    0,
   72     72   
)
   73     73   
.with_xml_name("attachTime");
   74     74   
static INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_ATTACHMENT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "com.amazonaws.ec2#InstanceNetworkInterfaceAttachment$AttachmentId",
   77     77   
        "com.amazonaws.ec2",
   78     78   
        "InstanceNetworkInterfaceAttachment",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "attachment_id",
          81  +
    "AttachmentId",
   82     82   
    1,
   83     83   
)
   84     84   
.with_xml_name("attachmentId");
   85     85   
static INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_DELETE_ON_TERMINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "com.amazonaws.ec2#InstanceNetworkInterfaceAttachment$DeleteOnTermination",
   88     88   
        "com.amazonaws.ec2",
   89     89   
        "InstanceNetworkInterfaceAttachment",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::Boolean,
   92         -
    "delete_on_termination",
          92  +
    "DeleteOnTermination",
   93     93   
    2,
   94     94   
)
   95     95   
.with_xml_name("deleteOnTermination");
   96     96   
static INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_DEVICE_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static(
   98     98   
        "com.amazonaws.ec2#InstanceNetworkInterfaceAttachment$DeviceIndex",
   99     99   
        "com.amazonaws.ec2",
  100    100   
        "InstanceNetworkInterfaceAttachment",
  101    101   
    ),
  102    102   
    ::aws_smithy_schema::ShapeType::Integer,
  103         -
    "device_index",
         103  +
    "DeviceIndex",
  104    104   
    3,
  105    105   
)
  106    106   
.with_xml_name("deviceIndex");
  107    107   
static INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.ec2#InstanceNetworkInterfaceAttachment$Status",
  110    110   
        "com.amazonaws.ec2",
  111    111   
        "InstanceNetworkInterfaceAttachment",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::String,
  114         -
    "status",
         114  +
    "Status",
  115    115   
    4,
  116    116   
)
  117    117   
.with_xml_name("status");
  118    118   
static INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_NETWORK_CARD_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.ec2#InstanceNetworkInterfaceAttachment$NetworkCardIndex",
  121    121   
        "com.amazonaws.ec2",
  122    122   
        "InstanceNetworkInterfaceAttachment",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::Integer,
  125         -
    "network_card_index",
         125  +
    "NetworkCardIndex",
  126    126   
    5,
  127    127   
)
  128    128   
.with_xml_name("networkCardIndex");
  129    129   
static INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_ENA_SRD_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static(
  131    131   
        "com.amazonaws.ec2#InstanceNetworkInterfaceAttachment$EnaSrdSpecification",
  132    132   
        "com.amazonaws.ec2",
  133    133   
        "InstanceNetworkInterfaceAttachment",
  134    134   
    ),
  135    135   
    ::aws_smithy_schema::ShapeType::Structure,
  136         -
    "ena_srd_specification",
         136  +
    "EnaSrdSpecification",
  137    137   
    6,
  138    138   
)
  139    139   
.with_xml_name("enaSrdSpecification");
  140    140   
static INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_ENA_QUEUE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static(
  142    142   
        "com.amazonaws.ec2#InstanceNetworkInterfaceAttachment$EnaQueueCount",
  143    143   
        "com.amazonaws.ec2",
  144    144   
        "InstanceNetworkInterfaceAttachment",
  145    145   
    ),
  146    146   
    ::aws_smithy_schema::ShapeType::Integer,
  147         -
    "ena_queue_count",
         147  +
    "EnaQueueCount",
  148    148   
    7,
  149    149   
)
  150    150   
.with_xml_name("enaQueueCount");
  151    151   
static INSTANCENETWORKINTERFACEATTACHMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  152    152   
    INSTANCENETWORKINTERFACEATTACHMENT_SCHEMA_ID,
  153    153   
    ::aws_smithy_schema::ShapeType::Structure,
  154    154   
    &[
  155    155   
        &INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_ATTACH_TIME,
  156    156   
        &INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_ATTACHMENT_ID,
  157    157   
        &INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_DELETE_ON_TERMINATION,
  158    158   
        &INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_DEVICE_INDEX,
  159    159   
        &INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_STATUS,
  160    160   
        &INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_NETWORK_CARD_INDEX,
  161    161   
        &INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_ENA_SRD_SPECIFICATION,
  162    162   
        &INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_ENA_QUEUE_COUNT,
  163    163   
    ],
  164    164   
);
  165    165   
impl InstanceNetworkInterfaceAttachment {
  166    166   
    /// The schema for this shape.
  167    167   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INSTANCENETWORKINTERFACEATTACHMENT_SCHEMA;
  168    168   
}
  169    169   
impl ::aws_smithy_schema::serde::SerializableStruct for InstanceNetworkInterfaceAttachment {
  170    170   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  171    171   
    fn serialize_members(
  172    172   
        &self,
  173    173   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  174    174   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  175    175   
        if let Some(ref val) = self.attach_time {
  176    176   
            ser.write_timestamp(&INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_ATTACH_TIME, val)?;
  177    177   
        }
  178    178   
        if let Some(ref val) = self.attachment_id {
  179    179   
            ser.write_string(&INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_ATTACHMENT_ID, val)?;
  180    180   
        }
  181    181   
        if let Some(ref val) = self.delete_on_termination {
  182    182   
            ser.write_boolean(&INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_DELETE_ON_TERMINATION, *val)?;
  183    183   
        }
  184    184   
        if let Some(ref val) = self.device_index {
  185    185   
            ser.write_integer(&INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_DEVICE_INDEX, *val)?;
  186    186   
        }
  187    187   
        if let Some(ref val) = self.status {
  188    188   
            ser.write_string(&INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_STATUS, val.as_str())?;
  189    189   
        }
  190    190   
        if let Some(ref val) = self.network_card_index {
  191    191   
            ser.write_integer(&INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_NETWORK_CARD_INDEX, *val)?;
  192    192   
        }
  193    193   
        if let Some(ref val) = self.ena_srd_specification {
  194    194   
            ser.write_struct(&INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_ENA_SRD_SPECIFICATION, val)?;
  195    195   
        }
  196    196   
        if let Some(ref val) = self.ena_queue_count {
  197    197   
            ser.write_integer(&INSTANCENETWORKINTERFACEATTACHMENT_MEMBER_ENA_QUEUE_COUNT, *val)?;
  198    198   
        }
  199    199   
        Ok(())
  200    200   
    }
  201    201   
}
  202    202   
impl InstanceNetworkInterfaceAttachment {
  203    203   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  204         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  205         -
        deserializer: &mut D,
         204  +
    pub fn deserialize(
         205  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  206    206   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  207    207   
        #[allow(unused_variables, unused_mut)]
  208    208   
        let mut builder = Self::builder();
  209    209   
        #[allow(
  210    210   
            unused_variables,
  211    211   
            unreachable_code,
  212    212   
            clippy::single_match,
  213    213   
            clippy::match_single_binding,
  214    214   
            clippy::diverging_sub_expression
  215    215   
        )]
  216         -
        deserializer.read_struct(&INSTANCENETWORKINTERFACEATTACHMENT_SCHEMA, (), |_, member, deser| {
         216  +
        deserializer.read_struct(&INSTANCENETWORKINTERFACEATTACHMENT_SCHEMA, &mut |member, deser| {
  217    217   
            match member.member_index() {
  218    218   
                Some(0) => {
  219    219   
                    builder.attach_time = Some(deser.read_timestamp(member)?);
  220    220   
                }
  221    221   
                Some(1) => {
  222    222   
                    builder.attachment_id = Some(deser.read_string(member)?);
  223    223   
                }
  224    224   
                Some(2) => {
  225    225   
                    builder.delete_on_termination = Some(deser.read_boolean(member)?);
  226    226   
                }
  227    227   
                Some(3) => {
  228    228   
                    builder.device_index = Some(deser.read_integer(member)?);
  229    229   
                }
  230    230   
                Some(4) => {
  231    231   
                    builder.status = Some(crate::types::AttachmentStatus::from(deser.read_string(member)?.as_str()));
  232    232   
                }
  233    233   
                Some(5) => {
  234    234   
                    builder.network_card_index = Some(deser.read_integer(member)?);
  235    235   
                }
  236    236   
                Some(6) => {
  237    237   
                    builder.ena_srd_specification = Some(crate::types::InstanceAttachmentEnaSrdSpecification::deserialize(deser)?);
  238    238   
                }
  239    239   
                Some(7) => {
  240    240   
                    builder.ena_queue_count = Some(deser.read_integer(member)?);
  241    241   
                }
  242    242   
                _ => {}
  243    243   
            }
  244    244   
            Ok(())
  245    245   
        })?;
  246    246   
        Ok(builder.build())
  247    247   
    }
  248    248   
}
         249  +
impl InstanceNetworkInterfaceAttachment {
         250  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         251  +
    pub fn deserialize_with_response(
         252  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         253  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         254  +
        _status: u16,
         255  +
        _body: &[u8],
         256  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         257  +
        Self::deserialize(deserializer)
         258  +
    }
         259  +
}
  249    260   
impl InstanceNetworkInterfaceAttachment {
  250    261   
    /// Creates a new builder-style object to manufacture [`InstanceNetworkInterfaceAttachment`](crate::types::InstanceNetworkInterfaceAttachment).
  251    262   
    pub fn builder() -> crate::types::builders::InstanceNetworkInterfaceAttachmentBuilder {
  252    263   
        crate::types::builders::InstanceNetworkInterfaceAttachmentBuilder::default()
  253    264   
    }
  254    265   
}
  255    266   
  256    267   
/// A builder for [`InstanceNetworkInterfaceAttachment`](crate::types::InstanceNetworkInterfaceAttachment).
  257    268   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  258    269   
#[non_exhaustive]