AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c

Files changed:

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

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

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

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

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

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

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

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

@@ -49,49 +181,181 @@
   69     69   
    /// <p>The ID of the Availability Zone.</p>
   70     70   
    pub fn availability_zone_id(&self) -> ::std::option::Option<&str> {
   71     71   
        self.availability_zone_id.as_deref()
   72     72   
    }
   73     73   
}
   74     74   
static VOLUMESTATUSITEM_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   75     75   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VolumeStatusItem", "com.amazonaws.ec2", "VolumeStatusItem");
   76     76   
static VOLUMESTATUSITEM_MEMBER_ACTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   77     77   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VolumeStatusItem$Actions", "com.amazonaws.ec2", "VolumeStatusItem"),
   78     78   
    ::aws_smithy_schema::ShapeType::List,
   79         -
    "actions",
          79  +
    "Actions",
   80     80   
    0,
   81     81   
)
   82     82   
.with_xml_name("actionsSet");
   83     83   
static VOLUMESTATUSITEM_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.ec2#VolumeStatusItem$AvailabilityZone",
   86     86   
        "com.amazonaws.ec2",
   87     87   
        "VolumeStatusItem",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "availability_zone",
          90  +
    "AvailabilityZone",
   91     91   
    1,
   92     92   
)
   93     93   
.with_xml_name("availabilityZone");
   94     94   
static VOLUMESTATUSITEM_MEMBER_OUTPOST_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VolumeStatusItem$OutpostArn", "com.amazonaws.ec2", "VolumeStatusItem"),
   96     96   
    ::aws_smithy_schema::ShapeType::String,
   97         -
    "outpost_arn",
          97  +
    "OutpostArn",
   98     98   
    2,
   99     99   
)
  100    100   
.with_xml_name("outpostArn");
  101    101   
static VOLUMESTATUSITEM_MEMBER_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VolumeStatusItem$Events", "com.amazonaws.ec2", "VolumeStatusItem"),
  103    103   
    ::aws_smithy_schema::ShapeType::List,
  104         -
    "events",
         104  +
    "Events",
  105    105   
    3,
  106    106   
)
  107    107   
.with_xml_name("eventsSet");
  108    108   
static VOLUMESTATUSITEM_MEMBER_VOLUME_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VolumeStatusItem$VolumeId", "com.amazonaws.ec2", "VolumeStatusItem"),
  110    110   
    ::aws_smithy_schema::ShapeType::String,
  111         -
    "volume_id",
         111  +
    "VolumeId",
  112    112   
    4,
  113    113   
)
  114    114   
.with_xml_name("volumeId");
  115    115   
static VOLUMESTATUSITEM_MEMBER_VOLUME_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VolumeStatusItem$VolumeStatus", "com.amazonaws.ec2", "VolumeStatusItem"),
  117    117   
    ::aws_smithy_schema::ShapeType::Structure,
  118         -
    "volume_status",
         118  +
    "VolumeStatus",
  119    119   
    5,
  120    120   
)
  121    121   
.with_xml_name("volumeStatus");
  122    122   
static VOLUMESTATUSITEM_MEMBER_ATTACHMENT_STATUSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  123    123   
    ::aws_smithy_schema::ShapeId::from_static(
  124    124   
        "com.amazonaws.ec2#VolumeStatusItem$AttachmentStatuses",
  125    125   
        "com.amazonaws.ec2",
  126    126   
        "VolumeStatusItem",
  127    127   
    ),
  128    128   
    ::aws_smithy_schema::ShapeType::List,
  129         -
    "attachment_statuses",
         129  +
    "AttachmentStatuses",
  130    130   
    6,
  131    131   
)
  132    132   
.with_xml_name("attachmentStatuses");
  133    133   
static VOLUMESTATUSITEM_MEMBER_INITIALIZATION_STATUS_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  134    134   
    ::aws_smithy_schema::ShapeId::from_static(
  135    135   
        "com.amazonaws.ec2#VolumeStatusItem$InitializationStatusDetails",
  136    136   
        "com.amazonaws.ec2",
  137    137   
        "VolumeStatusItem",
  138    138   
    ),
  139    139   
    ::aws_smithy_schema::ShapeType::Structure,
  140         -
    "initialization_status_details",
         140  +
    "InitializationStatusDetails",
  141    141   
    7,
  142    142   
)
  143    143   
.with_xml_name("initializationStatusDetails");
  144    144   
static VOLUMESTATUSITEM_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "com.amazonaws.ec2#VolumeStatusItem$AvailabilityZoneId",
  147    147   
        "com.amazonaws.ec2",
  148    148   
        "VolumeStatusItem",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::String,
  151         -
    "availability_zone_id",
         151  +
    "AvailabilityZoneId",
  152    152   
    8,
  153    153   
)
  154    154   
.with_xml_name("availabilityZoneId");
  155    155   
static VOLUMESTATUSITEM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  156    156   
    VOLUMESTATUSITEM_SCHEMA_ID,
  157    157   
    ::aws_smithy_schema::ShapeType::Structure,
  158    158   
    &[
  159    159   
        &VOLUMESTATUSITEM_MEMBER_ACTIONS,
  160    160   
        &VOLUMESTATUSITEM_MEMBER_AVAILABILITY_ZONE,
  161    161   
        &VOLUMESTATUSITEM_MEMBER_OUTPOST_ARN,
@@ -206,206 +343,345 @@
  226    226   
            ser.write_struct(&VOLUMESTATUSITEM_MEMBER_INITIALIZATION_STATUS_DETAILS, val)?;
  227    227   
        }
  228    228   
        if let Some(ref val) = self.availability_zone_id {
  229    229   
            ser.write_string(&VOLUMESTATUSITEM_MEMBER_AVAILABILITY_ZONE_ID, val)?;
  230    230   
        }
  231    231   
        Ok(())
  232    232   
    }
  233    233   
}
  234    234   
impl VolumeStatusItem {
  235    235   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  236         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  237         -
        deserializer: &mut D,
         236  +
    pub fn deserialize(
         237  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  238    238   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  239    239   
        #[allow(unused_variables, unused_mut)]
  240    240   
        let mut builder = Self::builder();
  241    241   
        #[allow(
  242    242   
            unused_variables,
  243    243   
            unreachable_code,
  244    244   
            clippy::single_match,
  245    245   
            clippy::match_single_binding,
  246    246   
            clippy::diverging_sub_expression
  247    247   
        )]
  248         -
        deserializer.read_struct(&VOLUMESTATUSITEM_SCHEMA, (), |_, member, deser| {
         248  +
        deserializer.read_struct(&VOLUMESTATUSITEM_SCHEMA, &mut |member, deser| {
  249    249   
            match member.member_index() {
  250    250   
                Some(0) => {
  251    251   
                    builder.actions = Some({
  252         -
                        let container = if let Some(cap) = deser.container_size() {
  253         -
                            Vec::with_capacity(cap)
  254         -
                        } else {
  255         -
                            Vec::new()
  256         -
                        };
  257         -
                        deser.read_list(member, container, |mut list, deser| {
  258         -
                            list.push(crate::types::VolumeStatusAction::deserialize(deser)?);
  259         -
                            Ok(list)
  260         -
                        })?
         252  +
                        let mut container = Vec::new();
         253  +
                        deser.read_list(member, &mut |deser| {
         254  +
                            container.push(crate::types::VolumeStatusAction::deserialize(deser)?);
         255  +
                            Ok(())
         256  +
                        })?;
         257  +
                        container
  261    258   
                    });
  262    259   
                }
  263    260   
                Some(1) => {
  264    261   
                    builder.availability_zone = Some(deser.read_string(member)?);
  265    262   
                }
  266    263   
                Some(2) => {
  267    264   
                    builder.outpost_arn = Some(deser.read_string(member)?);
  268    265   
                }
  269    266   
                Some(3) => {
  270    267   
                    builder.events = Some({
  271         -
                        let container = if let Some(cap) = deser.container_size() {
  272         -
                            Vec::with_capacity(cap)
  273         -
                        } else {
  274         -
                            Vec::new()
  275         -
                        };
  276         -
                        deser.read_list(member, container, |mut list, deser| {
  277         -
                            list.push(crate::types::VolumeStatusEvent::deserialize(deser)?);
  278         -
                            Ok(list)
  279         -
                        })?
         268  +
                        let mut container = Vec::new();
         269  +
                        deser.read_list(member, &mut |deser| {
         270  +
                            container.push(crate::types::VolumeStatusEvent::deserialize(deser)?);
         271  +
                            Ok(())
         272  +
                        })?;
         273  +
                        container
  280    274   
                    });
  281    275   
                }
  282    276   
                Some(4) => {
  283    277   
                    builder.volume_id = Some(deser.read_string(member)?);
  284    278   
                }
  285    279   
                Some(5) => {
  286    280   
                    builder.volume_status = Some(crate::types::VolumeStatusInfo::deserialize(deser)?);
  287    281   
                }
  288    282   
                Some(6) => {
  289    283   
                    builder.attachment_statuses = 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::VolumeStatusAttachmentStatus::deserialize(deser)?);
  297         -
                            Ok(list)
  298         -
                        })?
         284  +
                        let mut container = Vec::new();
         285  +
                        deser.read_list(member, &mut |deser| {
         286  +
                            container.push(crate::types::VolumeStatusAttachmentStatus::deserialize(deser)?);
         287  +
                            Ok(())
         288  +
                        })?;
         289  +
                        container
  299    290   
                    });
  300    291   
                }
  301    292   
                Some(7) => {
  302    293   
                    builder.initialization_status_details = Some(crate::types::InitializationStatusDetails::deserialize(deser)?);
  303    294   
                }
  304    295   
                Some(8) => {
  305    296   
                    builder.availability_zone_id = Some(deser.read_string(member)?);
  306    297   
                }
  307    298   
                _ => {}
  308    299   
            }
  309    300   
            Ok(())
  310    301   
        })?;
  311    302   
        Ok(builder.build())
  312    303   
    }
  313    304   
}
         305  +
impl VolumeStatusItem {
         306  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         307  +
    pub fn deserialize_with_response(
         308  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         309  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         310  +
        _status: u16,
         311  +
        _body: &[u8],
         312  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         313  +
        Self::deserialize(deserializer)
         314  +
    }
         315  +
}
  314    316   
impl VolumeStatusItem {
  315    317   
    /// Creates a new builder-style object to manufacture [`VolumeStatusItem`](crate::types::VolumeStatusItem).
  316    318   
    pub fn builder() -> crate::types::builders::VolumeStatusItemBuilder {
  317    319   
        crate::types::builders::VolumeStatusItemBuilder::default()
  318    320   
    }
  319    321   
}
  320    322   
  321    323   
/// A builder for [`VolumeStatusItem`](crate::types::VolumeStatusItem).
  322    324   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  323    325   
#[non_exhaustive]

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

@@ -62,62 +199,199 @@
   82     82   
    }
   83     83   
    /// <p>The ID of the set of DHCP options you've associated with the VPC.</p>
   84     84   
    pub fn dhcp_options_id(&self) -> ::std::option::Option<&str> {
   85     85   
        self.dhcp_options_id.as_deref()
   86     86   
    }
   87     87   
}
   88     88   
static VPC_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Vpc", "com.amazonaws.ec2", "Vpc");
   89     89   
static VPC_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Vpc$OwnerId", "com.amazonaws.ec2", "Vpc"),
   91     91   
    ::aws_smithy_schema::ShapeType::String,
   92         -
    "owner_id",
          92  +
    "OwnerId",
   93     93   
    0,
   94     94   
)
   95     95   
.with_xml_name("ownerId");
   96     96   
static VPC_MEMBER_INSTANCE_TENANCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Vpc$InstanceTenancy", "com.amazonaws.ec2", "Vpc"),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "instance_tenancy",
          99  +
    "InstanceTenancy",
  100    100   
    1,
  101    101   
)
  102    102   
.with_xml_name("instanceTenancy");
  103    103   
static VPC_MEMBER_IPV6_CIDR_BLOCK_ASSOCIATION_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Vpc$Ipv6CidrBlockAssociationSet", "com.amazonaws.ec2", "Vpc"),
  105    105   
    ::aws_smithy_schema::ShapeType::List,
  106         -
    "ipv6_cidr_block_association_set",
         106  +
    "Ipv6CidrBlockAssociationSet",
  107    107   
    2,
  108    108   
)
  109    109   
.with_xml_name("ipv6CidrBlockAssociationSet");
  110    110   
static VPC_MEMBER_CIDR_BLOCK_ASSOCIATION_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Vpc$CidrBlockAssociationSet", "com.amazonaws.ec2", "Vpc"),
  112    112   
    ::aws_smithy_schema::ShapeType::List,
  113         -
    "cidr_block_association_set",
         113  +
    "CidrBlockAssociationSet",
  114    114   
    3,
  115    115   
)
  116    116   
.with_xml_name("cidrBlockAssociationSet");
  117    117   
static VPC_MEMBER_IS_DEFAULT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Vpc$IsDefault", "com.amazonaws.ec2", "Vpc"),
  119    119   
    ::aws_smithy_schema::ShapeType::Boolean,
  120         -
    "is_default",
         120  +
    "IsDefault",
  121    121   
    4,
  122    122   
)
  123    123   
.with_xml_name("isDefault");
  124    124   
static VPC_MEMBER_ENCRYPTION_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Vpc$EncryptionControl", "com.amazonaws.ec2", "Vpc"),
  126    126   
    ::aws_smithy_schema::ShapeType::Structure,
  127         -
    "encryption_control",
         127  +
    "EncryptionControl",
  128    128   
    5,
  129    129   
)
  130    130   
.with_xml_name("encryptionControl");
  131    131   
static VPC_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  132    132   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Vpc$Tags", "com.amazonaws.ec2", "Vpc"),
  133    133   
    ::aws_smithy_schema::ShapeType::List,
  134         -
    "tags",
         134  +
    "Tags",
  135    135   
    6,
  136    136   
)
  137    137   
.with_xml_name("tagSet");
  138    138   
static VPC_MEMBER_BLOCK_PUBLIC_ACCESS_STATES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  139    139   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Vpc$BlockPublicAccessStates", "com.amazonaws.ec2", "Vpc"),
  140    140   
    ::aws_smithy_schema::ShapeType::Structure,
  141         -
    "block_public_access_states",
         141  +
    "BlockPublicAccessStates",
  142    142   
    7,
  143    143   
)
  144    144   
.with_xml_name("blockPublicAccessStates");
  145    145   
static VPC_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Vpc$VpcId", "com.amazonaws.ec2", "Vpc"),
  147    147   
    ::aws_smithy_schema::ShapeType::String,
  148         -
    "vpc_id",
         148  +
    "VpcId",
  149    149   
    8,
  150    150   
)
  151    151   
.with_xml_name("vpcId");
  152    152   
static VPC_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  153    153   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Vpc$State", "com.amazonaws.ec2", "Vpc"),
  154    154   
    ::aws_smithy_schema::ShapeType::String,
  155         -
    "state",
         155  +
    "State",
  156    156   
    9,
  157    157   
)
  158    158   
.with_xml_name("state");
  159    159   
static VPC_MEMBER_CIDR_BLOCK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  160    160   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Vpc$CidrBlock", "com.amazonaws.ec2", "Vpc"),
  161    161   
    ::aws_smithy_schema::ShapeType::String,
  162         -
    "cidr_block",
         162  +
    "CidrBlock",
  163    163   
    10,
  164    164   
)
  165    165   
.with_xml_name("cidrBlock");
  166    166   
static VPC_MEMBER_DHCP_OPTIONS_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  167    167   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Vpc$DhcpOptionsId", "com.amazonaws.ec2", "Vpc"),
  168    168   
    ::aws_smithy_schema::ShapeType::String,
  169         -
    "dhcp_options_id",
         169  +
    "DhcpOptionsId",
  170    170   
    11,
  171    171   
)
  172    172   
.with_xml_name("dhcpOptionsId");
  173    173   
static VPC_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  174    174   
    VPC_SCHEMA_ID,
  175    175   
    ::aws_smithy_schema::ShapeType::Structure,
  176    176   
    &[
  177    177   
        &VPC_MEMBER_OWNER_ID,
  178    178   
        &VPC_MEMBER_INSTANCE_TENANCY,
  179    179   
        &VPC_MEMBER_IPV6_CIDR_BLOCK_ASSOCIATION_SET,
@@ -233,233 +379,381 @@
  253    253   
            ser.write_string(&VPC_MEMBER_CIDR_BLOCK, val)?;
  254    254   
        }
  255    255   
        if let Some(ref val) = self.dhcp_options_id {
  256    256   
            ser.write_string(&VPC_MEMBER_DHCP_OPTIONS_ID, val)?;
  257    257   
        }
  258    258   
        Ok(())
  259    259   
    }
  260    260   
}
  261    261   
impl Vpc {
  262    262   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  263         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  264         -
        deserializer: &mut D,
         263  +
    pub fn deserialize(
         264  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  265    265   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  266    266   
        #[allow(unused_variables, unused_mut)]
  267    267   
        let mut builder = Self::builder();
  268    268   
        #[allow(
  269    269   
            unused_variables,
  270    270   
            unreachable_code,
  271    271   
            clippy::single_match,
  272    272   
            clippy::match_single_binding,
  273    273   
            clippy::diverging_sub_expression
  274    274   
        )]
  275         -
        deserializer.read_struct(&VPC_SCHEMA, (), |_, member, deser| {
         275  +
        deserializer.read_struct(&VPC_SCHEMA, &mut |member, deser| {
  276    276   
            match member.member_index() {
  277    277   
                Some(0) => {
  278    278   
                    builder.owner_id = Some(deser.read_string(member)?);
  279    279   
                }
  280    280   
                Some(1) => {
  281    281   
                    builder.instance_tenancy = Some(crate::types::Tenancy::from(deser.read_string(member)?.as_str()));
  282    282   
                }
  283    283   
                Some(2) => {
  284    284   
                    builder.ipv6_cidr_block_association_set = Some({
  285         -
                        let container = if let Some(cap) = deser.container_size() {
  286         -
                            Vec::with_capacity(cap)
  287         -
                        } else {
  288         -
                            Vec::new()
  289         -
                        };
  290         -
                        deser.read_list(member, container, |mut list, deser| {
  291         -
                            list.push(crate::types::VpcIpv6CidrBlockAssociation::deserialize(deser)?);
  292         -
                            Ok(list)
  293         -
                        })?
         285  +
                        let mut container = Vec::new();
         286  +
                        deser.read_list(member, &mut |deser| {
         287  +
                            container.push(crate::types::VpcIpv6CidrBlockAssociation::deserialize(deser)?);
         288  +
                            Ok(())
         289  +
                        })?;
         290  +
                        container
  294    291   
                    });
  295    292   
                }
  296    293   
                Some(3) => {
  297    294   
                    builder.cidr_block_association_set = Some({
  298         -
                        let container = if let Some(cap) = deser.container_size() {
  299         -
                            Vec::with_capacity(cap)
  300         -
                        } else {
  301         -
                            Vec::new()
  302         -
                        };
  303         -
                        deser.read_list(member, container, |mut list, deser| {
  304         -
                            list.push(crate::types::VpcCidrBlockAssociation::deserialize(deser)?);
  305         -
                            Ok(list)
  306         -
                        })?
         295  +
                        let mut container = Vec::new();
         296  +
                        deser.read_list(member, &mut |deser| {
         297  +
                            container.push(crate::types::VpcCidrBlockAssociation::deserialize(deser)?);
         298  +
                            Ok(())
         299  +
                        })?;
         300  +
                        container
  307    301   
                    });
  308    302   
                }
  309    303   
                Some(4) => {
  310    304   
                    builder.is_default = Some(deser.read_boolean(member)?);
  311    305   
                }
  312    306   
                Some(5) => {
  313    307   
                    builder.encryption_control = Some(crate::types::VpcEncryptionControl::deserialize(deser)?);
  314    308   
                }
  315    309   
                Some(6) => {
  316    310   
                    builder.tags = Some({
  317         -
                        let container = if let Some(cap) = deser.container_size() {
  318         -
                            Vec::with_capacity(cap)
  319         -
                        } else {
  320         -
                            Vec::new()
  321         -
                        };
  322         -
                        deser.read_list(member, container, |mut list, deser| {
  323         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  324         -
                            Ok(list)
  325         -
                        })?
         311  +
                        let mut container = Vec::new();
         312  +
                        deser.read_list(member, &mut |deser| {
         313  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         314  +
                            Ok(())
         315  +
                        })?;
         316  +
                        container
  326    317   
                    });
  327    318   
                }
  328    319   
                Some(7) => {
  329    320   
                    builder.block_public_access_states = Some(crate::types::BlockPublicAccessStates::deserialize(deser)?);
  330    321   
                }
  331    322   
                Some(8) => {
  332    323   
                    builder.vpc_id = Some(deser.read_string(member)?);
  333    324   
                }
  334    325   
                Some(9) => {
  335    326   
                    builder.state = Some(crate::types::VpcState::from(deser.read_string(member)?.as_str()));
  336    327   
                }
  337    328   
                Some(10) => {
  338    329   
                    builder.cidr_block = Some(deser.read_string(member)?);
  339    330   
                }
  340    331   
                Some(11) => {
  341    332   
                    builder.dhcp_options_id = Some(deser.read_string(member)?);
  342    333   
                }
  343    334   
                _ => {}
  344    335   
            }
  345    336   
            Ok(())
  346    337   
        })?;
  347    338   
        Ok(builder.build())
  348    339   
    }
  349    340   
}
         341  +
impl Vpc {
         342  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         343  +
    pub fn deserialize_with_response(
         344  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         345  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         346  +
        _status: u16,
         347  +
        _body: &[u8],
         348  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         349  +
        Self::deserialize(deserializer)
         350  +
    }
         351  +
}
  350    352   
impl Vpc {
  351    353   
    /// Creates a new builder-style object to manufacture [`Vpc`](crate::types::Vpc).
  352    354   
    pub fn builder() -> crate::types::builders::VpcBuilder {
  353    355   
        crate::types::builders::VpcBuilder::default()
  354    356   
    }
  355    357   
}
  356    358   
  357    359   
/// A builder for [`Vpc`](crate::types::Vpc).
  358    360   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  359    361   
#[non_exhaustive]

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

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

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

@@ -60,60 +208,208 @@
   80     80   
    "com.amazonaws.ec2",
   81     81   
    "VpcBlockPublicAccessExclusion",
   82     82   
);
   83     83   
static VPCBLOCKPUBLICACCESSEXCLUSION_MEMBER_EXCLUSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.ec2#VpcBlockPublicAccessExclusion$ExclusionId",
   86     86   
        "com.amazonaws.ec2",
   87     87   
        "VpcBlockPublicAccessExclusion",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "exclusion_id",
          90  +
    "ExclusionId",
   91     91   
    0,
   92     92   
)
   93     93   
.with_xml_name("exclusionId");
   94     94   
static VPCBLOCKPUBLICACCESSEXCLUSION_MEMBER_INTERNET_GATEWAY_EXCLUSION_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static(
   96     96   
        "com.amazonaws.ec2#VpcBlockPublicAccessExclusion$InternetGatewayExclusionMode",
   97     97   
        "com.amazonaws.ec2",
   98     98   
        "VpcBlockPublicAccessExclusion",
   99     99   
    ),
  100    100   
    ::aws_smithy_schema::ShapeType::String,
  101         -
    "internet_gateway_exclusion_mode",
         101  +
    "InternetGatewayExclusionMode",
  102    102   
    1,
  103    103   
)
  104    104   
.with_xml_name("internetGatewayExclusionMode");
  105    105   
static VPCBLOCKPUBLICACCESSEXCLUSION_MEMBER_RESOURCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static(
  107    107   
        "com.amazonaws.ec2#VpcBlockPublicAccessExclusion$ResourceArn",
  108    108   
        "com.amazonaws.ec2",
  109    109   
        "VpcBlockPublicAccessExclusion",
  110    110   
    ),
  111    111   
    ::aws_smithy_schema::ShapeType::String,
  112         -
    "resource_arn",
         112  +
    "ResourceArn",
  113    113   
    2,
  114    114   
)
  115    115   
.with_xml_name("resourceArn");
  116    116   
static VPCBLOCKPUBLICACCESSEXCLUSION_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  117    117   
    ::aws_smithy_schema::ShapeId::from_static(
  118    118   
        "com.amazonaws.ec2#VpcBlockPublicAccessExclusion$State",
  119    119   
        "com.amazonaws.ec2",
  120    120   
        "VpcBlockPublicAccessExclusion",
  121    121   
    ),
  122    122   
    ::aws_smithy_schema::ShapeType::String,
  123         -
    "state",
         123  +
    "State",
  124    124   
    3,
  125    125   
)
  126    126   
.with_xml_name("state");
  127    127   
static VPCBLOCKPUBLICACCESSEXCLUSION_MEMBER_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static(
  129    129   
        "com.amazonaws.ec2#VpcBlockPublicAccessExclusion$Reason",
  130    130   
        "com.amazonaws.ec2",
  131    131   
        "VpcBlockPublicAccessExclusion",
  132    132   
    ),
  133    133   
    ::aws_smithy_schema::ShapeType::String,
  134         -
    "reason",
         134  +
    "Reason",
  135    135   
    4,
  136    136   
)
  137    137   
.with_xml_name("reason");
  138    138   
static VPCBLOCKPUBLICACCESSEXCLUSION_MEMBER_CREATION_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  139    139   
    ::aws_smithy_schema::ShapeId::from_static(
  140    140   
        "com.amazonaws.ec2#VpcBlockPublicAccessExclusion$CreationTimestamp",
  141    141   
        "com.amazonaws.ec2",
  142    142   
        "VpcBlockPublicAccessExclusion",
  143    143   
    ),
  144    144   
    ::aws_smithy_schema::ShapeType::Timestamp,
  145         -
    "creation_timestamp",
         145  +
    "CreationTimestamp",
  146    146   
    5,
  147    147   
)
  148    148   
.with_xml_name("creationTimestamp");
  149    149   
static VPCBLOCKPUBLICACCESSEXCLUSION_MEMBER_LAST_UPDATE_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static(
  151    151   
        "com.amazonaws.ec2#VpcBlockPublicAccessExclusion$LastUpdateTimestamp",
  152    152   
        "com.amazonaws.ec2",
  153    153   
        "VpcBlockPublicAccessExclusion",
  154    154   
    ),
  155    155   
    ::aws_smithy_schema::ShapeType::Timestamp,
  156         -
    "last_update_timestamp",
         156  +
    "LastUpdateTimestamp",
  157    157   
    6,
  158    158   
)
  159    159   
.with_xml_name("lastUpdateTimestamp");
  160    160   
static VPCBLOCKPUBLICACCESSEXCLUSION_MEMBER_DELETION_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  161    161   
    ::aws_smithy_schema::ShapeId::from_static(
  162    162   
        "com.amazonaws.ec2#VpcBlockPublicAccessExclusion$DeletionTimestamp",
  163    163   
        "com.amazonaws.ec2",
  164    164   
        "VpcBlockPublicAccessExclusion",
  165    165   
    ),
  166    166   
    ::aws_smithy_schema::ShapeType::Timestamp,
  167         -
    "deletion_timestamp",
         167  +
    "DeletionTimestamp",
  168    168   
    7,
  169    169   
)
  170    170   
.with_xml_name("deletionTimestamp");
  171    171   
static VPCBLOCKPUBLICACCESSEXCLUSION_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  172    172   
    ::aws_smithy_schema::ShapeId::from_static(
  173    173   
        "com.amazonaws.ec2#VpcBlockPublicAccessExclusion$Tags",
  174    174   
        "com.amazonaws.ec2",
  175    175   
        "VpcBlockPublicAccessExclusion",
  176    176   
    ),
  177    177   
    ::aws_smithy_schema::ShapeType::List,
  178         -
    "tags",
         178  +
    "Tags",
  179    179   
    8,
  180    180   
)
  181    181   
.with_xml_name("tagSet");
  182    182   
static VPCBLOCKPUBLICACCESSEXCLUSION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  183    183   
    VPCBLOCKPUBLICACCESSEXCLUSION_SCHEMA_ID,
  184    184   
    ::aws_smithy_schema::ShapeType::Structure,
  185    185   
    &[
  186    186   
        &VPCBLOCKPUBLICACCESSEXCLUSION_MEMBER_EXCLUSION_ID,
  187    187   
        &VPCBLOCKPUBLICACCESSEXCLUSION_MEMBER_INTERNET_GATEWAY_EXCLUSION_MODE,
  188    188   
        &VPCBLOCKPUBLICACCESSEXCLUSION_MEMBER_RESOURCE_ARN,
@@ -217,217 +337,345 @@
  237    237   
                    }
  238    238   
                    Ok(())
  239    239   
                },
  240    240   
            )?;
  241    241   
        }
  242    242   
        Ok(())
  243    243   
    }
  244    244   
}
  245    245   
impl VpcBlockPublicAccessExclusion {
  246    246   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  247         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  248         -
        deserializer: &mut D,
         247  +
    pub fn deserialize(
         248  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  249    249   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  250    250   
        #[allow(unused_variables, unused_mut)]
  251    251   
        let mut builder = Self::builder();
  252    252   
        #[allow(
  253    253   
            unused_variables,
  254    254   
            unreachable_code,
  255    255   
            clippy::single_match,
  256    256   
            clippy::match_single_binding,
  257    257   
            clippy::diverging_sub_expression
  258    258   
        )]
  259         -
        deserializer.read_struct(&VPCBLOCKPUBLICACCESSEXCLUSION_SCHEMA, (), |_, member, deser| {
         259  +
        deserializer.read_struct(&VPCBLOCKPUBLICACCESSEXCLUSION_SCHEMA, &mut |member, deser| {
  260    260   
            match member.member_index() {
  261    261   
                Some(0) => {
  262    262   
                    builder.exclusion_id = Some(deser.read_string(member)?);
  263    263   
                }
  264    264   
                Some(1) => {
  265    265   
                    builder.internet_gateway_exclusion_mode =
  266    266   
                        Some(crate::types::InternetGatewayExclusionMode::from(deser.read_string(member)?.as_str()));
  267    267   
                }
  268    268   
                Some(2) => {
  269    269   
                    builder.resource_arn = Some(deser.read_string(member)?);
  270    270   
                }
  271    271   
                Some(3) => {
  272    272   
                    builder.state = Some(crate::types::VpcBlockPublicAccessExclusionState::from(
  273    273   
                        deser.read_string(member)?.as_str(),
  274    274   
                    ));
  275    275   
                }
  276    276   
                Some(4) => {
  277    277   
                    builder.reason = Some(deser.read_string(member)?);
  278    278   
                }
  279    279   
                Some(5) => {
  280    280   
                    builder.creation_timestamp = Some(deser.read_timestamp(member)?);
  281    281   
                }
  282    282   
                Some(6) => {
  283    283   
                    builder.last_update_timestamp = Some(deser.read_timestamp(member)?);
  284    284   
                }
  285    285   
                Some(7) => {
  286    286   
                    builder.deletion_timestamp = Some(deser.read_timestamp(member)?);
  287    287   
                }
  288    288   
                Some(8) => {
  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   
                _ => {}
  302    299   
            }
  303    300   
            Ok(())
  304    301   
        })?;
  305    302   
        Ok(builder.build())
  306    303   
    }
  307    304   
}
         305  +
impl VpcBlockPublicAccessExclusion {
         306  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         307  +
    pub fn deserialize_with_response(
         308  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         309  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         310  +
        _status: u16,
         311  +
        _body: &[u8],
         312  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         313  +
        Self::deserialize(deserializer)
         314  +
    }
         315  +
}
  308    316   
impl VpcBlockPublicAccessExclusion {
  309    317   
    /// Creates a new builder-style object to manufacture [`VpcBlockPublicAccessExclusion`](crate::types::VpcBlockPublicAccessExclusion).
  310    318   
    pub fn builder() -> crate::types::builders::VpcBlockPublicAccessExclusionBuilder {
  311    319   
        crate::types::builders::VpcBlockPublicAccessExclusionBuilder::default()
  312    320   
    }
  313    321   
}
  314    322   
  315    323   
/// A builder for [`VpcBlockPublicAccessExclusion`](crate::types::VpcBlockPublicAccessExclusion).
  316    324   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  317    325   
#[non_exhaustive]

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

@@ -68,68 +308,319 @@
   88     88   
    "com.amazonaws.ec2",
   89     89   
    "VpcBlockPublicAccessOptions",
   90     90   
);
   91     91   
static VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_AWS_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.ec2#VpcBlockPublicAccessOptions$AwsAccountId",
   94     94   
        "com.amazonaws.ec2",
   95     95   
        "VpcBlockPublicAccessOptions",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::String,
   98         -
    "aws_account_id",
          98  +
    "AwsAccountId",
   99     99   
    0,
  100    100   
)
  101    101   
.with_xml_name("awsAccountId");
  102    102   
static VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_AWS_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static(
  104    104   
        "com.amazonaws.ec2#VpcBlockPublicAccessOptions$AwsRegion",
  105    105   
        "com.amazonaws.ec2",
  106    106   
        "VpcBlockPublicAccessOptions",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "aws_region",
         109  +
    "AwsRegion",
  110    110   
    1,
  111    111   
)
  112    112   
.with_xml_name("awsRegion");
  113    113   
static VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static(
  115    115   
        "com.amazonaws.ec2#VpcBlockPublicAccessOptions$State",
  116    116   
        "com.amazonaws.ec2",
  117    117   
        "VpcBlockPublicAccessOptions",
  118    118   
    ),
  119    119   
    ::aws_smithy_schema::ShapeType::String,
  120         -
    "state",
         120  +
    "State",
  121    121   
    2,
  122    122   
)
  123    123   
.with_xml_name("state");
  124    124   
static VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_INTERNET_GATEWAY_BLOCK_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static(
  126    126   
        "com.amazonaws.ec2#VpcBlockPublicAccessOptions$InternetGatewayBlockMode",
  127    127   
        "com.amazonaws.ec2",
  128    128   
        "VpcBlockPublicAccessOptions",
  129    129   
    ),
  130    130   
    ::aws_smithy_schema::ShapeType::String,
  131         -
    "internet_gateway_block_mode",
         131  +
    "InternetGatewayBlockMode",
  132    132   
    3,
  133    133   
)
  134    134   
.with_xml_name("internetGatewayBlockMode");
  135    135   
static VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static(
  137    137   
        "com.amazonaws.ec2#VpcBlockPublicAccessOptions$Reason",
  138    138   
        "com.amazonaws.ec2",
  139    139   
        "VpcBlockPublicAccessOptions",
  140    140   
    ),
  141    141   
    ::aws_smithy_schema::ShapeType::String,
  142         -
    "reason",
         142  +
    "Reason",
  143    143   
    4,
  144    144   
)
  145    145   
.with_xml_name("reason");
  146    146   
static VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_LAST_UPDATE_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  147    147   
    ::aws_smithy_schema::ShapeId::from_static(
  148    148   
        "com.amazonaws.ec2#VpcBlockPublicAccessOptions$LastUpdateTimestamp",
  149    149   
        "com.amazonaws.ec2",
  150    150   
        "VpcBlockPublicAccessOptions",
  151    151   
    ),
  152    152   
    ::aws_smithy_schema::ShapeType::Timestamp,
  153         -
    "last_update_timestamp",
         153  +
    "LastUpdateTimestamp",
  154    154   
    5,
  155    155   
)
  156    156   
.with_xml_name("lastUpdateTimestamp");
  157    157   
static VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_MANAGED_BY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  158    158   
    ::aws_smithy_schema::ShapeId::from_static(
  159    159   
        "com.amazonaws.ec2#VpcBlockPublicAccessOptions$ManagedBy",
  160    160   
        "com.amazonaws.ec2",
  161    161   
        "VpcBlockPublicAccessOptions",
  162    162   
    ),
  163    163   
    ::aws_smithy_schema::ShapeType::String,
  164         -
    "managed_by",
         164  +
    "ManagedBy",
  165    165   
    6,
  166    166   
)
  167    167   
.with_xml_name("managedBy");
  168    168   
static VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_EXCLUSIONS_ALLOWED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  169    169   
    ::aws_smithy_schema::ShapeId::from_static(
  170    170   
        "com.amazonaws.ec2#VpcBlockPublicAccessOptions$ExclusionsAllowed",
  171    171   
        "com.amazonaws.ec2",
  172    172   
        "VpcBlockPublicAccessOptions",
  173    173   
    ),
  174    174   
    ::aws_smithy_schema::ShapeType::String,
  175         -
    "exclusions_allowed",
         175  +
    "ExclusionsAllowed",
  176    176   
    7,
  177    177   
)
  178    178   
.with_xml_name("exclusionsAllowed");
  179    179   
static VPCBLOCKPUBLICACCESSOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  180    180   
    VPCBLOCKPUBLICACCESSOPTIONS_SCHEMA_ID,
  181    181   
    ::aws_smithy_schema::ShapeType::Structure,
  182    182   
    &[
  183    183   
        &VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_AWS_ACCOUNT_ID,
  184    184   
        &VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_AWS_REGION,
  185    185   
        &VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_STATE,
  186    186   
        &VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_INTERNET_GATEWAY_BLOCK_MODE,
  187    187   
        &VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_REASON,
  188    188   
        &VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_LAST_UPDATE_TIMESTAMP,
  189    189   
        &VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_MANAGED_BY,
  190    190   
        &VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_EXCLUSIONS_ALLOWED,
  191    191   
    ],
  192    192   
);
  193    193   
impl VpcBlockPublicAccessOptions {
  194    194   
    /// The schema for this shape.
  195    195   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPCBLOCKPUBLICACCESSOPTIONS_SCHEMA;
  196    196   
}
  197    197   
impl ::aws_smithy_schema::serde::SerializableStruct for VpcBlockPublicAccessOptions {
  198    198   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  199    199   
    fn serialize_members(
  200    200   
        &self,
  201    201   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  202    202   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  203    203   
        if let Some(ref val) = self.aws_account_id {
  204    204   
            ser.write_string(&VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_AWS_ACCOUNT_ID, val)?;
  205    205   
        }
  206    206   
        if let Some(ref val) = self.aws_region {
  207    207   
            ser.write_string(&VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_AWS_REGION, val)?;
  208    208   
        }
  209    209   
        if let Some(ref val) = self.state {
  210    210   
            ser.write_string(&VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_STATE, val.as_str())?;
  211    211   
        }
  212    212   
        if let Some(ref val) = self.internet_gateway_block_mode {
  213    213   
            ser.write_string(&VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_INTERNET_GATEWAY_BLOCK_MODE, val.as_str())?;
  214    214   
        }
  215    215   
        if let Some(ref val) = self.reason {
  216    216   
            ser.write_string(&VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_REASON, val)?;
  217    217   
        }
  218    218   
        if let Some(ref val) = self.last_update_timestamp {
  219    219   
            ser.write_timestamp(&VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_LAST_UPDATE_TIMESTAMP, val)?;
  220    220   
        }
  221    221   
        if let Some(ref val) = self.managed_by {
  222    222   
            ser.write_string(&VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_MANAGED_BY, val.as_str())?;
  223    223   
        }
  224    224   
        if let Some(ref val) = self.exclusions_allowed {
  225    225   
            ser.write_string(&VPCBLOCKPUBLICACCESSOPTIONS_MEMBER_EXCLUSIONS_ALLOWED, val.as_str())?;
  226    226   
        }
  227    227   
        Ok(())
  228    228   
    }
  229    229   
}
  230    230   
impl VpcBlockPublicAccessOptions {
  231    231   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  232         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  233         -
        deserializer: &mut D,
         232  +
    pub fn deserialize(
         233  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  234    234   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  235    235   
        #[allow(unused_variables, unused_mut)]
  236    236   
        let mut builder = Self::builder();
  237    237   
        #[allow(
  238    238   
            unused_variables,
  239    239   
            unreachable_code,
  240    240   
            clippy::single_match,
  241    241   
            clippy::match_single_binding,
  242    242   
            clippy::diverging_sub_expression
  243    243   
        )]
  244         -
        deserializer.read_struct(&VPCBLOCKPUBLICACCESSOPTIONS_SCHEMA, (), |_, member, deser| {
         244  +
        deserializer.read_struct(&VPCBLOCKPUBLICACCESSOPTIONS_SCHEMA, &mut |member, deser| {
  245    245   
            match member.member_index() {
  246    246   
                Some(0) => {
  247    247   
                    builder.aws_account_id = Some(deser.read_string(member)?);
  248    248   
                }
  249    249   
                Some(1) => {
  250    250   
                    builder.aws_region = Some(deser.read_string(member)?);
  251    251   
                }
  252    252   
                Some(2) => {
  253    253   
                    builder.state = Some(crate::types::VpcBlockPublicAccessState::from(deser.read_string(member)?.as_str()));
  254    254   
                }
  255    255   
                Some(3) => {
  256    256   
                    builder.internet_gateway_block_mode = Some(crate::types::InternetGatewayBlockMode::from(deser.read_string(member)?.as_str()));
  257    257   
                }
  258    258   
                Some(4) => {
  259    259   
                    builder.reason = Some(deser.read_string(member)?);
  260    260   
                }
  261    261   
                Some(5) => {
  262    262   
                    builder.last_update_timestamp = Some(deser.read_timestamp(member)?);
  263    263   
                }
  264    264   
                Some(6) => {
  265    265   
                    builder.managed_by = Some(crate::types::ManagedBy::from(deser.read_string(member)?.as_str()));
  266    266   
                }
  267    267   
                Some(7) => {
  268    268   
                    builder.exclusions_allowed = Some(crate::types::VpcBlockPublicAccessExclusionsAllowed::from(
  269    269   
                        deser.read_string(member)?.as_str(),
  270    270   
                    ));
  271    271   
                }
  272    272   
                _ => {}
  273    273   
            }
  274    274   
            Ok(())
  275    275   
        })?;
  276    276   
        Ok(builder.build())
  277    277   
    }
  278    278   
}
         279  +
impl VpcBlockPublicAccessOptions {
         280  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         281  +
    pub fn deserialize_with_response(
         282  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         283  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         284  +
        _status: u16,
         285  +
        _body: &[u8],
         286  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         287  +
        Self::deserialize(deserializer)
         288  +
    }
         289  +
}
  279    290   
impl VpcBlockPublicAccessOptions {
  280    291   
    /// Creates a new builder-style object to manufacture [`VpcBlockPublicAccessOptions`](crate::types::VpcBlockPublicAccessOptions).
  281    292   
    pub fn builder() -> crate::types::builders::VpcBlockPublicAccessOptionsBuilder {
  282    293   
        crate::types::builders::VpcBlockPublicAccessOptionsBuilder::default()
  283    294   
    }
  284    295   
}
  285    296   
  286    297   
/// A builder for [`VpcBlockPublicAccessOptions`](crate::types::VpcBlockPublicAccessOptions).
  287    298   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  288    299   
#[non_exhaustive]

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

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

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

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

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

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

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

@@ -32,32 +262,270 @@
   52     52   
}
   53     53   
static VPCENCRYPTIONCONTROL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   54     54   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEncryptionControl", "com.amazonaws.ec2", "VpcEncryptionControl");
   55     55   
static VPCENCRYPTIONCONTROL_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.ec2#VpcEncryptionControl$VpcId",
   58     58   
        "com.amazonaws.ec2",
   59     59   
        "VpcEncryptionControl",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::String,
   62         -
    "vpc_id",
          62  +
    "VpcId",
   63     63   
    0,
   64     64   
)
   65     65   
.with_xml_name("vpcId");
   66     66   
static VPCENCRYPTIONCONTROL_MEMBER_VPC_ENCRYPTION_CONTROL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "com.amazonaws.ec2#VpcEncryptionControl$VpcEncryptionControlId",
   69     69   
        "com.amazonaws.ec2",
   70     70   
        "VpcEncryptionControl",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::String,
   73         -
    "vpc_encryption_control_id",
          73  +
    "VpcEncryptionControlId",
   74     74   
    1,
   75     75   
)
   76     76   
.with_xml_name("vpcEncryptionControlId");
   77     77   
static VPCENCRYPTIONCONTROL_MEMBER_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEncryptionControl$Mode", "com.amazonaws.ec2", "VpcEncryptionControl"),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "mode",
          80  +
    "Mode",
   81     81   
    2,
   82     82   
)
   83     83   
.with_xml_name("mode");
   84     84   
static VPCENCRYPTIONCONTROL_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "com.amazonaws.ec2#VpcEncryptionControl$State",
   87     87   
        "com.amazonaws.ec2",
   88     88   
        "VpcEncryptionControl",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::String,
   91         -
    "state",
          91  +
    "State",
   92     92   
    3,
   93     93   
)
   94     94   
.with_xml_name("state");
   95     95   
static VPCENCRYPTIONCONTROL_MEMBER_STATE_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.ec2#VpcEncryptionControl$StateMessage",
   98     98   
        "com.amazonaws.ec2",
   99     99   
        "VpcEncryptionControl",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::String,
  102         -
    "state_message",
         102  +
    "StateMessage",
  103    103   
    4,
  104    104   
)
  105    105   
.with_xml_name("stateMessage");
  106    106   
static VPCENCRYPTIONCONTROL_MEMBER_RESOURCE_EXCLUSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.ec2#VpcEncryptionControl$ResourceExclusions",
  109    109   
        "com.amazonaws.ec2",
  110    110   
        "VpcEncryptionControl",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::Structure,
  113         -
    "resource_exclusions",
         113  +
    "ResourceExclusions",
  114    114   
    5,
  115    115   
)
  116    116   
.with_xml_name("resourceExclusions");
  117    117   
static VPCENCRYPTIONCONTROL_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEncryptionControl$Tags", "com.amazonaws.ec2", "VpcEncryptionControl"),
  119    119   
    ::aws_smithy_schema::ShapeType::List,
  120         -
    "tags",
         120  +
    "Tags",
  121    121   
    6,
  122    122   
)
  123    123   
.with_xml_name("tagSet");
  124    124   
static VPCENCRYPTIONCONTROL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  125    125   
    VPCENCRYPTIONCONTROL_SCHEMA_ID,
  126    126   
    ::aws_smithy_schema::ShapeType::Structure,
  127    127   
    &[
  128    128   
        &VPCENCRYPTIONCONTROL_MEMBER_VPC_ID,
  129    129   
        &VPCENCRYPTIONCONTROL_MEMBER_VPC_ENCRYPTION_CONTROL_ID,
  130    130   
        &VPCENCRYPTIONCONTROL_MEMBER_MODE,
  131    131   
        &VPCENCRYPTIONCONTROL_MEMBER_STATE,
  132    132   
        &VPCENCRYPTIONCONTROL_MEMBER_STATE_MESSAGE,
  133    133   
        &VPCENCRYPTIONCONTROL_MEMBER_RESOURCE_EXCLUSIONS,
  134    134   
        &VPCENCRYPTIONCONTROL_MEMBER_TAGS,
  135    135   
    ],
  136    136   
);
  137    137   
impl VpcEncryptionControl {
  138    138   
    /// The schema for this shape.
  139    139   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VPCENCRYPTIONCONTROL_SCHEMA;
  140    140   
}
  141    141   
impl ::aws_smithy_schema::serde::SerializableStruct for VpcEncryptionControl {
  142    142   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  143    143   
    fn serialize_members(
  144    144   
        &self,
  145    145   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  146    146   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  147    147   
        if let Some(ref val) = self.vpc_id {
  148    148   
            ser.write_string(&VPCENCRYPTIONCONTROL_MEMBER_VPC_ID, val)?;
  149    149   
        }
  150    150   
        if let Some(ref val) = self.vpc_encryption_control_id {
  151    151   
            ser.write_string(&VPCENCRYPTIONCONTROL_MEMBER_VPC_ENCRYPTION_CONTROL_ID, val)?;
  152    152   
        }
  153    153   
        if let Some(ref val) = self.mode {
  154    154   
            ser.write_string(&VPCENCRYPTIONCONTROL_MEMBER_MODE, val.as_str())?;
  155    155   
        }
  156    156   
        if let Some(ref val) = self.state {
  157    157   
            ser.write_string(&VPCENCRYPTIONCONTROL_MEMBER_STATE, val.as_str())?;
  158    158   
        }
  159    159   
        if let Some(ref val) = self.state_message {
  160    160   
            ser.write_string(&VPCENCRYPTIONCONTROL_MEMBER_STATE_MESSAGE, val)?;
  161    161   
        }
  162    162   
        if let Some(ref val) = self.resource_exclusions {
  163    163   
            ser.write_struct(&VPCENCRYPTIONCONTROL_MEMBER_RESOURCE_EXCLUSIONS, val)?;
  164    164   
        }
  165    165   
        if let Some(ref val) = self.tags {
  166    166   
            ser.write_list(
  167    167   
                &VPCENCRYPTIONCONTROL_MEMBER_TAGS,
  168    168   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  169    169   
                    for item in val {
  170    170   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  171    171   
                    }
  172    172   
                    Ok(())
  173    173   
                },
  174    174   
            )?;
  175    175   
        }
  176    176   
        Ok(())
  177    177   
    }
  178    178   
}
  179    179   
impl VpcEncryptionControl {
  180    180   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  181         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  182         -
        deserializer: &mut D,
         181  +
    pub fn deserialize(
         182  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  183    183   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  184    184   
        #[allow(unused_variables, unused_mut)]
  185    185   
        let mut builder = Self::builder();
  186    186   
        #[allow(
  187    187   
            unused_variables,
  188    188   
            unreachable_code,
  189    189   
            clippy::single_match,
  190    190   
            clippy::match_single_binding,
  191    191   
            clippy::diverging_sub_expression
  192    192   
        )]
  193         -
        deserializer.read_struct(&VPCENCRYPTIONCONTROL_SCHEMA, (), |_, member, deser| {
         193  +
        deserializer.read_struct(&VPCENCRYPTIONCONTROL_SCHEMA, &mut |member, deser| {
  194    194   
            match member.member_index() {
  195    195   
                Some(0) => {
  196    196   
                    builder.vpc_id = Some(deser.read_string(member)?);
  197    197   
                }
  198    198   
                Some(1) => {
  199    199   
                    builder.vpc_encryption_control_id = Some(deser.read_string(member)?);
  200    200   
                }
  201    201   
                Some(2) => {
  202    202   
                    builder.mode = Some(crate::types::VpcEncryptionControlMode::from(deser.read_string(member)?.as_str()));
  203    203   
                }
  204    204   
                Some(3) => {
  205    205   
                    builder.state = Some(crate::types::VpcEncryptionControlState::from(deser.read_string(member)?.as_str()));
  206    206   
                }
  207    207   
                Some(4) => {
  208    208   
                    builder.state_message = Some(deser.read_string(member)?);
  209    209   
                }
  210    210   
                Some(5) => {
  211    211   
                    builder.resource_exclusions = Some(crate::types::VpcEncryptionControlExclusions::deserialize(deser)?);
  212    212   
                }
  213    213   
                Some(6) => {
  214    214   
                    builder.tags = Some({
  215         -
                        let container = if let Some(cap) = deser.container_size() {
  216         -
                            Vec::with_capacity(cap)
  217         -
                        } else {
  218         -
                            Vec::new()
  219         -
                        };
  220         -
                        deser.read_list(member, container, |mut list, deser| {
  221         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  222         -
                            Ok(list)
  223         -
                        })?
         215  +
                        let mut container = Vec::new();
         216  +
                        deser.read_list(member, &mut |deser| {
         217  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         218  +
                            Ok(())
         219  +
                        })?;
         220  +
                        container
  224    221   
                    });
  225    222   
                }
  226    223   
                _ => {}
  227    224   
            }
  228    225   
            Ok(())
  229    226   
        })?;
  230    227   
        Ok(builder.build())
  231    228   
    }
  232    229   
}
         230  +
impl VpcEncryptionControl {
         231  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         232  +
    pub fn deserialize_with_response(
         233  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         234  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         235  +
        _status: u16,
         236  +
        _body: &[u8],
         237  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         238  +
        Self::deserialize(deserializer)
         239  +
    }
         240  +
}
  233    241   
impl VpcEncryptionControl {
  234    242   
    /// Creates a new builder-style object to manufacture [`VpcEncryptionControl`](crate::types::VpcEncryptionControl).
  235    243   
    pub fn builder() -> crate::types::builders::VpcEncryptionControlBuilder {
  236    244   
        crate::types::builders::VpcEncryptionControlBuilder::default()
  237    245   
    }
  238    246   
}
  239    247   
  240    248   
/// A builder for [`VpcEncryptionControl`](crate::types::VpcEncryptionControl).
  241    249   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  242    250   
#[non_exhaustive]

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

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

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

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

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

@@ -151,151 +383,383 @@
  171    171   
    /// <p>The Region where the service is hosted.</p>
  172    172   
    pub fn service_region(&self) -> ::std::option::Option<&str> {
  173    173   
        self.service_region.as_deref()
  174    174   
    }
  175    175   
}
  176    176   
static VPCENDPOINT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  177    177   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint", "com.amazonaws.ec2", "VpcEndpoint");
  178    178   
static VPCENDPOINT_MEMBER_VPC_ENDPOINT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$VpcEndpointId", "com.amazonaws.ec2", "VpcEndpoint"),
  180    180   
    ::aws_smithy_schema::ShapeType::String,
  181         -
    "vpc_endpoint_id",
         181  +
    "VpcEndpointId",
  182    182   
    0,
  183    183   
)
  184    184   
.with_xml_name("vpcEndpointId");
  185    185   
static VPCENDPOINT_MEMBER_VPC_ENDPOINT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  186    186   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$VpcEndpointType", "com.amazonaws.ec2", "VpcEndpoint"),
  187    187   
    ::aws_smithy_schema::ShapeType::String,
  188         -
    "vpc_endpoint_type",
         188  +
    "VpcEndpointType",
  189    189   
    1,
  190    190   
)
  191    191   
.with_xml_name("vpcEndpointType");
  192    192   
static VPCENDPOINT_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  193    193   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$VpcId", "com.amazonaws.ec2", "VpcEndpoint"),
  194    194   
    ::aws_smithy_schema::ShapeType::String,
  195         -
    "vpc_id",
         195  +
    "VpcId",
  196    196   
    2,
  197    197   
)
  198    198   
.with_xml_name("vpcId");
  199    199   
static VPCENDPOINT_MEMBER_SERVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  200    200   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$ServiceName", "com.amazonaws.ec2", "VpcEndpoint"),
  201    201   
    ::aws_smithy_schema::ShapeType::String,
  202         -
    "service_name",
         202  +
    "ServiceName",
  203    203   
    3,
  204    204   
)
  205    205   
.with_xml_name("serviceName");
  206    206   
static VPCENDPOINT_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  207    207   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$State", "com.amazonaws.ec2", "VpcEndpoint"),
  208    208   
    ::aws_smithy_schema::ShapeType::String,
  209         -
    "state",
         209  +
    "State",
  210    210   
    4,
  211    211   
)
  212    212   
.with_xml_name("state");
  213    213   
static VPCENDPOINT_MEMBER_POLICY_DOCUMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  214    214   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$PolicyDocument", "com.amazonaws.ec2", "VpcEndpoint"),
  215    215   
    ::aws_smithy_schema::ShapeType::String,
  216         -
    "policy_document",
         216  +
    "PolicyDocument",
  217    217   
    5,
  218    218   
)
  219    219   
.with_xml_name("policyDocument");
  220    220   
static VPCENDPOINT_MEMBER_ROUTE_TABLE_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  221    221   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$RouteTableIds", "com.amazonaws.ec2", "VpcEndpoint"),
  222    222   
    ::aws_smithy_schema::ShapeType::List,
  223         -
    "route_table_ids",
         223  +
    "RouteTableIds",
  224    224   
    6,
  225    225   
)
  226    226   
.with_xml_name("routeTableIdSet");
  227    227   
static VPCENDPOINT_MEMBER_SUBNET_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  228    228   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$SubnetIds", "com.amazonaws.ec2", "VpcEndpoint"),
  229    229   
    ::aws_smithy_schema::ShapeType::List,
  230         -
    "subnet_ids",
         230  +
    "SubnetIds",
  231    231   
    7,
  232    232   
)
  233    233   
.with_xml_name("subnetIdSet");
  234    234   
static VPCENDPOINT_MEMBER_GROUPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  235    235   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$Groups", "com.amazonaws.ec2", "VpcEndpoint"),
  236    236   
    ::aws_smithy_schema::ShapeType::List,
  237         -
    "groups",
         237  +
    "Groups",
  238    238   
    8,
  239    239   
)
  240    240   
.with_xml_name("groupSet");
  241    241   
static VPCENDPOINT_MEMBER_IP_ADDRESS_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  242    242   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$IpAddressType", "com.amazonaws.ec2", "VpcEndpoint"),
  243    243   
    ::aws_smithy_schema::ShapeType::String,
  244         -
    "ip_address_type",
         244  +
    "IpAddressType",
  245    245   
    9,
  246    246   
)
  247    247   
.with_xml_name("ipAddressType");
  248    248   
static VPCENDPOINT_MEMBER_DNS_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  249    249   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$DnsOptions", "com.amazonaws.ec2", "VpcEndpoint"),
  250    250   
    ::aws_smithy_schema::ShapeType::Structure,
  251         -
    "dns_options",
         251  +
    "DnsOptions",
  252    252   
    10,
  253    253   
)
  254    254   
.with_xml_name("dnsOptions");
  255    255   
static VPCENDPOINT_MEMBER_PRIVATE_DNS_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  256    256   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$PrivateDnsEnabled", "com.amazonaws.ec2", "VpcEndpoint"),
  257    257   
    ::aws_smithy_schema::ShapeType::Boolean,
  258         -
    "private_dns_enabled",
         258  +
    "PrivateDnsEnabled",
  259    259   
    11,
  260    260   
)
  261    261   
.with_xml_name("privateDnsEnabled");
  262    262   
static VPCENDPOINT_MEMBER_REQUESTER_MANAGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  263    263   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$RequesterManaged", "com.amazonaws.ec2", "VpcEndpoint"),
  264    264   
    ::aws_smithy_schema::ShapeType::Boolean,
  265         -
    "requester_managed",
         265  +
    "RequesterManaged",
  266    266   
    12,
  267    267   
)
  268    268   
.with_xml_name("requesterManaged");
  269    269   
static VPCENDPOINT_MEMBER_NETWORK_INTERFACE_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  270    270   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$NetworkInterfaceIds", "com.amazonaws.ec2", "VpcEndpoint"),
  271    271   
    ::aws_smithy_schema::ShapeType::List,
  272         -
    "network_interface_ids",
         272  +
    "NetworkInterfaceIds",
  273    273   
    13,
  274    274   
)
  275    275   
.with_xml_name("networkInterfaceIdSet");
  276    276   
static VPCENDPOINT_MEMBER_DNS_ENTRIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  277    277   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$DnsEntries", "com.amazonaws.ec2", "VpcEndpoint"),
  278    278   
    ::aws_smithy_schema::ShapeType::List,
  279         -
    "dns_entries",
         279  +
    "DnsEntries",
  280    280   
    14,
  281    281   
)
  282    282   
.with_xml_name("dnsEntrySet");
  283    283   
static VPCENDPOINT_MEMBER_CREATION_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  284    284   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$CreationTimestamp", "com.amazonaws.ec2", "VpcEndpoint"),
  285    285   
    ::aws_smithy_schema::ShapeType::Timestamp,
  286         -
    "creation_timestamp",
         286  +
    "CreationTimestamp",
  287    287   
    15,
  288    288   
)
  289    289   
.with_xml_name("creationTimestamp");
  290    290   
static VPCENDPOINT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  291    291   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$Tags", "com.amazonaws.ec2", "VpcEndpoint"),
  292    292   
    ::aws_smithy_schema::ShapeType::List,
  293         -
    "tags",
         293  +
    "Tags",
  294    294   
    16,
  295    295   
)
  296    296   
.with_xml_name("tagSet");
  297    297   
static VPCENDPOINT_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  298    298   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$OwnerId", "com.amazonaws.ec2", "VpcEndpoint"),
  299    299   
    ::aws_smithy_schema::ShapeType::String,
  300         -
    "owner_id",
         300  +
    "OwnerId",
  301    301   
    17,
  302    302   
)
  303    303   
.with_xml_name("ownerId");
  304    304   
static VPCENDPOINT_MEMBER_LAST_ERROR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  305    305   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$LastError", "com.amazonaws.ec2", "VpcEndpoint"),
  306    306   
    ::aws_smithy_schema::ShapeType::Structure,
  307         -
    "last_error",
         307  +
    "LastError",
  308    308   
    18,
  309    309   
)
  310    310   
.with_xml_name("lastError");
  311    311   
static VPCENDPOINT_MEMBER_IPV4_PREFIXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  312    312   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$Ipv4Prefixes", "com.amazonaws.ec2", "VpcEndpoint"),
  313    313   
    ::aws_smithy_schema::ShapeType::List,
  314         -
    "ipv4_prefixes",
         314  +
    "Ipv4Prefixes",
  315    315   
    19,
  316    316   
)
  317    317   
.with_xml_name("ipv4PrefixSet");
  318    318   
static VPCENDPOINT_MEMBER_IPV6_PREFIXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  319    319   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$Ipv6Prefixes", "com.amazonaws.ec2", "VpcEndpoint"),
  320    320   
    ::aws_smithy_schema::ShapeType::List,
  321         -
    "ipv6_prefixes",
         321  +
    "Ipv6Prefixes",
  322    322   
    20,
  323    323   
)
  324    324   
.with_xml_name("ipv6PrefixSet");
  325    325   
static VPCENDPOINT_MEMBER_FAILURE_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  326    326   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$FailureReason", "com.amazonaws.ec2", "VpcEndpoint"),
  327    327   
    ::aws_smithy_schema::ShapeType::String,
  328         -
    "failure_reason",
         328  +
    "FailureReason",
  329    329   
    21,
  330    330   
)
  331    331   
.with_xml_name("failureReason");
  332    332   
static VPCENDPOINT_MEMBER_SERVICE_NETWORK_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  333    333   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$ServiceNetworkArn", "com.amazonaws.ec2", "VpcEndpoint"),
  334    334   
    ::aws_smithy_schema::ShapeType::String,
  335         -
    "service_network_arn",
         335  +
    "ServiceNetworkArn",
  336    336   
    22,
  337    337   
)
  338    338   
.with_xml_name("serviceNetworkArn");
  339    339   
static VPCENDPOINT_MEMBER_RESOURCE_CONFIGURATION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  340    340   
    ::aws_smithy_schema::ShapeId::from_static(
  341    341   
        "com.amazonaws.ec2#VpcEndpoint$ResourceConfigurationArn",
  342    342   
        "com.amazonaws.ec2",
  343    343   
        "VpcEndpoint",
  344    344   
    ),
  345    345   
    ::aws_smithy_schema::ShapeType::String,
  346         -
    "resource_configuration_arn",
         346  +
    "ResourceConfigurationArn",
  347    347   
    23,
  348    348   
)
  349    349   
.with_xml_name("resourceConfigurationArn");
  350    350   
static VPCENDPOINT_MEMBER_SERVICE_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  351    351   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#VpcEndpoint$ServiceRegion", "com.amazonaws.ec2", "VpcEndpoint"),
  352    352   
    ::aws_smithy_schema::ShapeType::String,
  353         -
    "service_region",
         353  +
    "ServiceRegion",
  354    354   
    24,
  355    355   
)
  356    356   
.with_xml_name("serviceRegion");
  357    357   
static VPCENDPOINT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  358    358   
    VPCENDPOINT_SCHEMA_ID,
  359    359   
    ::aws_smithy_schema::ShapeType::Structure,
  360    360   
    &[
  361    361   
        &VPCENDPOINT_MEMBER_VPC_ENDPOINT_ID,
  362    362   
        &VPCENDPOINT_MEMBER_VPC_ENDPOINT_TYPE,
  363    363   
        &VPCENDPOINT_MEMBER_VPC_ID,
@@ -509,509 +744,710 @@
  529    529   
            ser.write_string(&VPCENDPOINT_MEMBER_RESOURCE_CONFIGURATION_ARN, val)?;
  530    530   
        }
  531    531   
        if let Some(ref val) = self.service_region {
  532    532   
            ser.write_string(&VPCENDPOINT_MEMBER_SERVICE_REGION, val)?;
  533    533   
        }
  534    534   
        Ok(())
  535    535   
    }
  536    536   
}
  537    537   
impl VpcEndpoint {
  538    538   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  539         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  540         -
        deserializer: &mut D,
         539  +
    pub fn deserialize(
         540  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  541    541   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  542    542   
        #[allow(unused_variables, unused_mut)]
  543    543   
        let mut builder = Self::builder();
  544    544   
        #[allow(
  545    545   
            unused_variables,
  546    546   
            unreachable_code,
  547    547   
            clippy::single_match,
  548    548   
            clippy::match_single_binding,
  549    549   
            clippy::diverging_sub_expression
  550    550   
        )]
  551         -
        deserializer.read_struct(&VPCENDPOINT_SCHEMA, (), |_, member, deser| {
         551  +
        deserializer.read_struct(&VPCENDPOINT_SCHEMA, &mut |member, deser| {
  552    552   
            match member.member_index() {
  553    553   
                Some(0) => {
  554    554   
                    builder.vpc_endpoint_id = Some(deser.read_string(member)?);
  555    555   
                }
  556    556   
                Some(1) => {
  557    557   
                    builder.vpc_endpoint_type = Some(crate::types::VpcEndpointType::from(deser.read_string(member)?.as_str()));
  558    558   
                }
  559    559   
                Some(2) => {
  560    560   
                    builder.vpc_id = Some(deser.read_string(member)?);
  561    561   
                }
  562    562   
                Some(3) => {
  563    563   
                    builder.service_name = Some(deser.read_string(member)?);
  564    564   
                }
  565    565   
                Some(4) => {
  566    566   
                    builder.state = Some(crate::types::State::from(deser.read_string(member)?.as_str()));
  567    567   
                }
  568    568   
                Some(5) => {
  569    569   
                    builder.policy_document = Some(deser.read_string(member)?);
  570    570   
                }
  571    571   
                Some(6) => {
  572         -
                    builder.route_table_ids = Some({
  573         -
                        let container = if let Some(cap) = deser.container_size() {
  574         -
                            Vec::with_capacity(cap)
  575         -
                        } else {
  576         -
                            Vec::new()
  577         -
                        };
  578         -
                        deser.read_list(member, container, |mut list, deser| {
  579         -
                            list.push(deser.read_string(member)?);
  580         -
                            Ok(list)
  581         -
                        })?
  582         -
                    });
         572  +
                    builder.route_table_ids = Some(deser.read_string_list(member)?);
  583    573   
                }
  584    574   
                Some(7) => {
  585         -
                    builder.subnet_ids = Some({
  586         -
                        let container = if let Some(cap) = deser.container_size() {
  587         -
                            Vec::with_capacity(cap)
  588         -
                        } else {
  589         -
                            Vec::new()
  590         -
                        };
  591         -
                        deser.read_list(member, container, |mut list, deser| {
  592         -
                            list.push(deser.read_string(member)?);
  593         -
                            Ok(list)
  594         -
                        })?
  595         -
                    });
         575  +
                    builder.subnet_ids = Some(deser.read_string_list(member)?);
  596    576   
                }
  597    577   
                Some(8) => {
  598    578   
                    builder.groups = Some({
  599         -
                        let container = if let Some(cap) = deser.container_size() {
  600         -
                            Vec::with_capacity(cap)
  601         -
                        } else {
  602         -
                            Vec::new()
  603         -
                        };
  604         -
                        deser.read_list(member, container, |mut list, deser| {
  605         -
                            list.push(crate::types::SecurityGroupIdentifier::deserialize(deser)?);
  606         -
                            Ok(list)
  607         -
                        })?
         579  +
                        let mut container = Vec::new();
         580  +
                        deser.read_list(member, &mut |deser| {
         581  +
                            container.push(crate::types::SecurityGroupIdentifier::deserialize(deser)?);
         582  +
                            Ok(())
         583  +
                        })?;
         584  +
                        container
  608    585   
                    });
  609    586   
                }
  610    587   
                Some(9) => {
  611    588   
                    builder.ip_address_type = Some(crate::types::IpAddressType::from(deser.read_string(member)?.as_str()));
  612    589   
                }
  613    590   
                Some(10) => {
  614    591   
                    builder.dns_options = Some(crate::types::DnsOptions::deserialize(deser)?);
  615    592   
                }
  616    593   
                Some(11) => {
  617    594   
                    builder.private_dns_enabled = Some(deser.read_boolean(member)?);
  618    595   
                }
  619    596   
                Some(12) => {
  620    597   
                    builder.requester_managed = Some(deser.read_boolean(member)?);
  621    598   
                }
  622    599   
                Some(13) => {
  623         -
                    builder.network_interface_ids = Some({
  624         -
                        let container = if let Some(cap) = deser.container_size() {
  625         -
                            Vec::with_capacity(cap)
  626         -
                        } else {
  627         -
                            Vec::new()
  628         -
                        };
  629         -
                        deser.read_list(member, container, |mut list, deser| {
  630         -
                            list.push(deser.read_string(member)?);
  631         -
                            Ok(list)
  632         -
                        })?
  633         -
                    });
         600  +
                    builder.network_interface_ids = Some(deser.read_string_list(member)?);
  634    601   
                }
  635    602   
                Some(14) => {
  636    603   
                    builder.dns_entries = Some({
  637         -
                        let container = if let Some(cap) = deser.container_size() {
  638         -
                            Vec::with_capacity(cap)
  639         -
                        } else {
  640         -
                            Vec::new()
  641         -
                        };
  642         -
                        deser.read_list(member, container, |mut list, deser| {
  643         -
                            list.push(crate::types::DnsEntry::deserialize(deser)?);
  644         -
                            Ok(list)
  645         -
                        })?
         604  +
                        let mut container = Vec::new();
         605  +
                        deser.read_list(member, &mut |deser| {
         606  +
                            container.push(crate::types::DnsEntry::deserialize(deser)?);
         607  +
                            Ok(())
         608  +
                        })?;
         609  +
                        container
  646    610   
                    });
  647    611   
                }
  648    612   
                Some(15) => {
  649    613   
                    builder.creation_timestamp = Some(deser.read_timestamp(member)?);
  650    614   
                }
  651    615   
                Some(16) => {
  652    616   
                    builder.tags = Some({
  653         -
                        let container = if let Some(cap) = deser.container_size() {
  654         -
                            Vec::with_capacity(cap)
  655         -
                        } else {
  656         -
                            Vec::new()
  657         -
                        };
  658         -
                        deser.read_list(member, container, |mut list, deser| {
  659         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  660         -
                            Ok(list)
  661         -
                        })?
         617  +
                        let mut container = Vec::new();
         618  +
                        deser.read_list(member, &mut |deser| {
         619  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         620  +
                            Ok(())
         621  +
                        })?;
         622  +
                        container
  662    623   
                    });
  663    624   
                }
  664    625   
                Some(17) => {
  665    626   
                    builder.owner_id = Some(deser.read_string(member)?);
  666    627   
                }
  667    628   
                Some(18) => {
  668    629   
                    builder.last_error = Some(crate::types::LastError::deserialize(deser)?);
  669    630   
                }
  670    631   
                Some(19) => {
  671    632   
                    builder.ipv4_prefixes = Some({
  672         -
                        let container = if let Some(cap) = deser.container_size() {
  673         -
                            Vec::with_capacity(cap)
  674         -
                        } else {
  675         -
                            Vec::new()
  676         -
                        };
  677         -
                        deser.read_list(member, container, |mut list, deser| {
  678         -
                            list.push(crate::types::SubnetIpPrefixes::deserialize(deser)?);
  679         -
                            Ok(list)
  680         -
                        })?
         633  +
                        let mut container = Vec::new();
         634  +
                        deser.read_list(member, &mut |deser| {
         635  +
                            container.push(crate::types::SubnetIpPrefixes::deserialize(deser)?);
         636  +
                            Ok(())
         637  +
                        })?;
         638  +
                        container
  681    639   
                    });
  682    640   
                }
  683    641   
                Some(20) => {
  684    642   
                    builder.ipv6_prefixes = Some({
  685         -
                        let container = if let Some(cap) = deser.container_size() {
  686         -
                            Vec::with_capacity(cap)
  687         -
                        } else {
  688         -
                            Vec::new()
  689         -
                        };
  690         -
                        deser.read_list(member, container, |mut list, deser| {
  691         -
                            list.push(crate::types::SubnetIpPrefixes::deserialize(deser)?);
  692         -
                            Ok(list)
  693         -
                        })?
         643  +
                        let mut container = Vec::new();
         644  +
                        deser.read_list(member, &mut |deser| {
         645  +
                            container.push(crate::types::SubnetIpPrefixes::deserialize(deser)?);
         646  +
                            Ok(())
         647  +
                        })?;
         648  +
                        container
  694    649   
                    });
  695    650   
                }
  696    651   
                Some(21) => {
  697    652   
                    builder.failure_reason = Some(deser.read_string(member)?);
  698    653   
                }
  699    654   
                Some(22) => {
  700    655   
                    builder.service_network_arn = Some(deser.read_string(member)?);
  701    656   
                }
  702    657   
                Some(23) => {
  703    658   
                    builder.resource_configuration_arn = Some(deser.read_string(member)?);
  704    659   
                }
  705    660   
                Some(24) => {
  706    661   
                    builder.service_region = Some(deser.read_string(member)?);
  707    662   
                }
  708    663   
                _ => {}
  709    664   
            }
  710    665   
            Ok(())
  711    666   
        })?;
  712    667   
        Ok(builder.build())
  713    668   
    }
  714    669   
}
         670  +
impl VpcEndpoint {
         671  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         672  +
    pub fn deserialize_with_response(
         673  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         674  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         675  +
        _status: u16,
         676  +
        _body: &[u8],
         677  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         678  +
        Self::deserialize(deserializer)
         679  +
    }
         680  +
}
  715    681   
impl VpcEndpoint {
  716    682   
    /// Creates a new builder-style object to manufacture [`VpcEndpoint`](crate::types::VpcEndpoint).
  717    683   
    pub fn builder() -> crate::types::builders::VpcEndpointBuilder {
  718    684   
        crate::types::builders::VpcEndpointBuilder::default()
  719    685   
    }
  720    686   
}
  721    687   
  722    688   
/// A builder for [`VpcEndpoint`](crate::types::VpcEndpoint).
  723    689   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  724    690   
#[non_exhaustive]