AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406 (ignoring whitespace)

Files changed:

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

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

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

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

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

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

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

@@ -70,70 +240,240 @@
   90     90   
    "com.amazonaws.ec2",
   91     91   
    "EnableFastSnapshotRestoreSuccessItem",
   92     92   
);
   93     93   
static ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.ec2#EnableFastSnapshotRestoreSuccessItem$SnapshotId",
   96     96   
        "com.amazonaws.ec2",
   97     97   
        "EnableFastSnapshotRestoreSuccessItem",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "snapshot_id",
         100  +
    "SnapshotId",
  101    101   
    0,
  102    102   
)
  103    103   
.with_xml_name("snapshotId");
  104    104   
static ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static(
  106    106   
        "com.amazonaws.ec2#EnableFastSnapshotRestoreSuccessItem$AvailabilityZone",
  107    107   
        "com.amazonaws.ec2",
  108    108   
        "EnableFastSnapshotRestoreSuccessItem",
  109    109   
    ),
  110    110   
    ::aws_smithy_schema::ShapeType::String,
  111         -
    "availability_zone",
         111  +
    "AvailabilityZone",
  112    112   
    1,
  113    113   
)
  114    114   
.with_xml_name("availabilityZone");
  115    115   
static ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static(
  117    117   
        "com.amazonaws.ec2#EnableFastSnapshotRestoreSuccessItem$State",
  118    118   
        "com.amazonaws.ec2",
  119    119   
        "EnableFastSnapshotRestoreSuccessItem",
  120    120   
    ),
  121    121   
    ::aws_smithy_schema::ShapeType::String,
  122         -
    "state",
         122  +
    "State",
  123    123   
    2,
  124    124   
)
  125    125   
.with_xml_name("state");
  126    126   
static ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_STATE_TRANSITION_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  127    127   
    ::aws_smithy_schema::ShapeId::from_static(
  128    128   
        "com.amazonaws.ec2#EnableFastSnapshotRestoreSuccessItem$StateTransitionReason",
  129    129   
        "com.amazonaws.ec2",
  130    130   
        "EnableFastSnapshotRestoreSuccessItem",
  131    131   
    ),
  132    132   
    ::aws_smithy_schema::ShapeType::String,
  133         -
    "state_transition_reason",
         133  +
    "StateTransitionReason",
  134    134   
    3,
  135    135   
)
  136    136   
.with_xml_name("stateTransitionReason");
  137    137   
static ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static(
  139    139   
        "com.amazonaws.ec2#EnableFastSnapshotRestoreSuccessItem$OwnerId",
  140    140   
        "com.amazonaws.ec2",
  141    141   
        "EnableFastSnapshotRestoreSuccessItem",
  142    142   
    ),
  143    143   
    ::aws_smithy_schema::ShapeType::String,
  144         -
    "owner_id",
         144  +
    "OwnerId",
  145    145   
    4,
  146    146   
)
  147    147   
.with_xml_name("ownerId");
  148    148   
static ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_OWNER_ALIAS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  149    149   
    ::aws_smithy_schema::ShapeId::from_static(
  150    150   
        "com.amazonaws.ec2#EnableFastSnapshotRestoreSuccessItem$OwnerAlias",
  151    151   
        "com.amazonaws.ec2",
  152    152   
        "EnableFastSnapshotRestoreSuccessItem",
  153    153   
    ),
  154    154   
    ::aws_smithy_schema::ShapeType::String,
  155         -
    "owner_alias",
         155  +
    "OwnerAlias",
  156    156   
    5,
  157    157   
)
  158    158   
.with_xml_name("ownerAlias");
  159    159   
static ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_ENABLING_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  160    160   
    ::aws_smithy_schema::ShapeId::from_static(
  161    161   
        "com.amazonaws.ec2#EnableFastSnapshotRestoreSuccessItem$EnablingTime",
  162    162   
        "com.amazonaws.ec2",
  163    163   
        "EnableFastSnapshotRestoreSuccessItem",
  164    164   
    ),
  165    165   
    ::aws_smithy_schema::ShapeType::Timestamp,
  166         -
    "enabling_time",
         166  +
    "EnablingTime",
  167    167   
    6,
  168    168   
)
  169    169   
.with_xml_name("enablingTime");
  170    170   
static ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_OPTIMIZING_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  171    171   
    ::aws_smithy_schema::ShapeId::from_static(
  172    172   
        "com.amazonaws.ec2#EnableFastSnapshotRestoreSuccessItem$OptimizingTime",
  173    173   
        "com.amazonaws.ec2",
  174    174   
        "EnableFastSnapshotRestoreSuccessItem",
  175    175   
    ),
  176    176   
    ::aws_smithy_schema::ShapeType::Timestamp,
  177         -
    "optimizing_time",
         177  +
    "OptimizingTime",
  178    178   
    7,
  179    179   
)
  180    180   
.with_xml_name("optimizingTime");
  181    181   
static ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_ENABLED_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  182    182   
    ::aws_smithy_schema::ShapeId::from_static(
  183    183   
        "com.amazonaws.ec2#EnableFastSnapshotRestoreSuccessItem$EnabledTime",
  184    184   
        "com.amazonaws.ec2",
  185    185   
        "EnableFastSnapshotRestoreSuccessItem",
  186    186   
    ),
  187    187   
    ::aws_smithy_schema::ShapeType::Timestamp,
  188         -
    "enabled_time",
         188  +
    "EnabledTime",
  189    189   
    8,
  190    190   
)
  191    191   
.with_xml_name("enabledTime");
  192    192   
static ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_DISABLING_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  193    193   
    ::aws_smithy_schema::ShapeId::from_static(
  194    194   
        "com.amazonaws.ec2#EnableFastSnapshotRestoreSuccessItem$DisablingTime",
  195    195   
        "com.amazonaws.ec2",
  196    196   
        "EnableFastSnapshotRestoreSuccessItem",
  197    197   
    ),
  198    198   
    ::aws_smithy_schema::ShapeType::Timestamp,
  199         -
    "disabling_time",
         199  +
    "DisablingTime",
  200    200   
    9,
  201    201   
)
  202    202   
.with_xml_name("disablingTime");
  203    203   
static ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_DISABLED_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  204    204   
    ::aws_smithy_schema::ShapeId::from_static(
  205    205   
        "com.amazonaws.ec2#EnableFastSnapshotRestoreSuccessItem$DisabledTime",
  206    206   
        "com.amazonaws.ec2",
  207    207   
        "EnableFastSnapshotRestoreSuccessItem",
  208    208   
    ),
  209    209   
    ::aws_smithy_schema::ShapeType::Timestamp,
  210         -
    "disabled_time",
         210  +
    "DisabledTime",
  211    211   
    10,
  212    212   
)
  213    213   
.with_xml_name("disabledTime");
  214    214   
static ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  215    215   
    ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_SCHEMA_ID,
  216    216   
    ::aws_smithy_schema::ShapeType::Structure,
  217    217   
    &[
  218    218   
        &ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_SNAPSHOT_ID,
  219    219   
        &ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_AVAILABILITY_ZONE,
  220    220   
        &ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_STATE,
@@ -249,249 +362,373 @@
  269    269   
            ser.write_timestamp(&ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_DISABLING_TIME, val)?;
  270    270   
        }
  271    271   
        if let Some(ref val) = self.disabled_time {
  272    272   
            ser.write_timestamp(&ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_MEMBER_DISABLED_TIME, val)?;
  273    273   
        }
  274    274   
        Ok(())
  275    275   
    }
  276    276   
}
  277    277   
impl EnableFastSnapshotRestoreSuccessItem {
  278    278   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  279         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  280         -
        deserializer: &mut D,
         279  +
    pub fn deserialize(
         280  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  281    281   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  282    282   
        #[allow(unused_variables, unused_mut)]
  283    283   
        let mut builder = Self::builder();
  284    284   
        #[allow(
  285    285   
            unused_variables,
  286    286   
            unreachable_code,
  287    287   
            clippy::single_match,
  288    288   
            clippy::match_single_binding,
  289    289   
            clippy::diverging_sub_expression
  290    290   
        )]
  291         -
        deserializer.read_struct(&ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_SCHEMA, (), |_, member, deser| {
         291  +
        deserializer.read_struct(&ENABLEFASTSNAPSHOTRESTORESUCCESSITEM_SCHEMA, &mut |member, deser| {
  292    292   
            match member.member_index() {
  293    293   
                Some(0) => {
  294    294   
                    builder.snapshot_id = Some(deser.read_string(member)?);
  295    295   
                }
  296    296   
                Some(1) => {
  297    297   
                    builder.availability_zone = Some(deser.read_string(member)?);
  298    298   
                }
  299    299   
                Some(2) => {
  300    300   
                    builder.state = Some(crate::types::FastSnapshotRestoreStateCode::from(deser.read_string(member)?.as_str()));
  301    301   
                }
  302    302   
                Some(3) => {
  303    303   
                    builder.state_transition_reason = Some(deser.read_string(member)?);
  304    304   
                }
  305    305   
                Some(4) => {
  306    306   
                    builder.owner_id = Some(deser.read_string(member)?);
  307    307   
                }
  308    308   
                Some(5) => {
  309    309   
                    builder.owner_alias = Some(deser.read_string(member)?);
  310    310   
                }
  311    311   
                Some(6) => {
  312    312   
                    builder.enabling_time = Some(deser.read_timestamp(member)?);
  313    313   
                }
  314    314   
                Some(7) => {
  315    315   
                    builder.optimizing_time = Some(deser.read_timestamp(member)?);
  316    316   
                }
  317    317   
                Some(8) => {
  318    318   
                    builder.enabled_time = Some(deser.read_timestamp(member)?);
  319    319   
                }
  320    320   
                Some(9) => {
  321    321   
                    builder.disabling_time = Some(deser.read_timestamp(member)?);
  322    322   
                }
  323    323   
                Some(10) => {
  324    324   
                    builder.disabled_time = Some(deser.read_timestamp(member)?);
  325    325   
                }
  326    326   
                _ => {}
  327    327   
            }
  328    328   
            Ok(())
  329    329   
        })?;
  330    330   
        Ok(builder.build())
  331    331   
    }
  332    332   
}
         333  +
impl EnableFastSnapshotRestoreSuccessItem {
         334  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         335  +
    pub fn deserialize_with_response(
         336  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         337  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         338  +
        _status: u16,
         339  +
        _body: &[u8],
         340  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         341  +
        Self::deserialize(deserializer)
         342  +
    }
         343  +
}
  333    344   
impl EnableFastSnapshotRestoreSuccessItem {
  334    345   
    /// Creates a new builder-style object to manufacture [`EnableFastSnapshotRestoreSuccessItem`](crate::types::EnableFastSnapshotRestoreSuccessItem).
  335    346   
    pub fn builder() -> crate::types::builders::EnableFastSnapshotRestoreSuccessItemBuilder {
  336    347   
        crate::types::builders::EnableFastSnapshotRestoreSuccessItemBuilder::default()
  337    348   
    }
  338    349   
}
  339    350   
  340    351   
/// A builder for [`EnableFastSnapshotRestoreSuccessItem`](crate::types::EnableFastSnapshotRestoreSuccessItem).
  341    352   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  342    353   
#[non_exhaustive]

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

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

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

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

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

@@ -113,113 +253,264 @@
  133    133   
}
  134    134   
static EVENTINFORMATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  135    135   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#EventInformation", "com.amazonaws.ec2", "EventInformation");
  136    136   
static EVENTINFORMATION_MEMBER_EVENT_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  137    137   
    ::aws_smithy_schema::ShapeId::from_static(
  138    138   
        "com.amazonaws.ec2#EventInformation$EventDescription",
  139    139   
        "com.amazonaws.ec2",
  140    140   
        "EventInformation",
  141    141   
    ),
  142    142   
    ::aws_smithy_schema::ShapeType::String,
  143         -
    "event_description",
         143  +
    "EventDescription",
  144    144   
    0,
  145    145   
)
  146    146   
.with_xml_name("eventDescription");
  147    147   
static EVENTINFORMATION_MEMBER_EVENT_SUB_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  148    148   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#EventInformation$EventSubType", "com.amazonaws.ec2", "EventInformation"),
  149    149   
    ::aws_smithy_schema::ShapeType::String,
  150         -
    "event_sub_type",
         150  +
    "EventSubType",
  151    151   
    1,
  152    152   
)
  153    153   
.with_xml_name("eventSubType");
  154    154   
static EVENTINFORMATION_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  155    155   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#EventInformation$InstanceId", "com.amazonaws.ec2", "EventInformation"),
  156    156   
    ::aws_smithy_schema::ShapeType::String,
  157         -
    "instance_id",
         157  +
    "InstanceId",
  158    158   
    2,
  159    159   
)
  160    160   
.with_xml_name("instanceId");
  161    161   
static EVENTINFORMATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  162    162   
    EVENTINFORMATION_SCHEMA_ID,
  163    163   
    ::aws_smithy_schema::ShapeType::Structure,
  164    164   
    &[
  165    165   
        &EVENTINFORMATION_MEMBER_EVENT_DESCRIPTION,
  166    166   
        &EVENTINFORMATION_MEMBER_EVENT_SUB_TYPE,
  167    167   
        &EVENTINFORMATION_MEMBER_INSTANCE_ID,
  168    168   
    ],
  169    169   
);
  170    170   
impl EventInformation {
  171    171   
    /// The schema for this shape.
  172    172   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EVENTINFORMATION_SCHEMA;
  173    173   
}
  174    174   
impl ::aws_smithy_schema::serde::SerializableStruct for EventInformation {
  175    175   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  176    176   
    fn serialize_members(
  177    177   
        &self,
  178    178   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  179    179   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  180    180   
        if let Some(ref val) = self.event_description {
  181    181   
            ser.write_string(&EVENTINFORMATION_MEMBER_EVENT_DESCRIPTION, val)?;
  182    182   
        }
  183    183   
        if let Some(ref val) = self.event_sub_type {
  184    184   
            ser.write_string(&EVENTINFORMATION_MEMBER_EVENT_SUB_TYPE, val)?;
  185    185   
        }
  186    186   
        if let Some(ref val) = self.instance_id {
  187    187   
            ser.write_string(&EVENTINFORMATION_MEMBER_INSTANCE_ID, val)?;
  188    188   
        }
  189    189   
        Ok(())
  190    190   
    }
  191    191   
}
  192    192   
impl EventInformation {
  193    193   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  194         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  195         -
        deserializer: &mut D,
         194  +
    pub fn deserialize(
         195  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  196    196   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  197    197   
        #[allow(unused_variables, unused_mut)]
  198    198   
        let mut builder = Self::builder();
  199    199   
        #[allow(
  200    200   
            unused_variables,
  201    201   
            unreachable_code,
  202    202   
            clippy::single_match,
  203    203   
            clippy::match_single_binding,
  204    204   
            clippy::diverging_sub_expression
  205    205   
        )]
  206         -
        deserializer.read_struct(&EVENTINFORMATION_SCHEMA, (), |_, member, deser| {
         206  +
        deserializer.read_struct(&EVENTINFORMATION_SCHEMA, &mut |member, deser| {
  207    207   
            match member.member_index() {
  208    208   
                Some(0) => {
  209    209   
                    builder.event_description = Some(deser.read_string(member)?);
  210    210   
                }
  211    211   
                Some(1) => {
  212    212   
                    builder.event_sub_type = Some(deser.read_string(member)?);
  213    213   
                }
  214    214   
                Some(2) => {
  215    215   
                    builder.instance_id = Some(deser.read_string(member)?);
  216    216   
                }
  217    217   
                _ => {}
  218    218   
            }
  219    219   
            Ok(())
  220    220   
        })?;
  221    221   
        Ok(builder.build())
  222    222   
    }
  223    223   
}
         224  +
impl EventInformation {
         225  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         226  +
    pub fn deserialize_with_response(
         227  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         228  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         229  +
        _status: u16,
         230  +
        _body: &[u8],
         231  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         232  +
        Self::deserialize(deserializer)
         233  +
    }
         234  +
}
  224    235   
impl EventInformation {
  225    236   
    /// Creates a new builder-style object to manufacture [`EventInformation`](crate::types::EventInformation).
  226    237   
    pub fn builder() -> crate::types::builders::EventInformationBuilder {
  227    238   
        crate::types::builders::EventInformationBuilder::default()
  228    239   
    }
  229    240   
}
  230    241   
  231    242   
/// A builder for [`EventInformation`](crate::types::EventInformation).
  232    243   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  233    244   
#[non_exhaustive]

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

@@ -337,337 +800,800 @@
  357    357   
    /// <p>The Network Firewall stateful rule.</p>
  358    358   
    pub fn firewall_stateful_rule(&self) -> ::std::option::Option<&crate::types::FirewallStatefulRule> {
  359    359   
        self.firewall_stateful_rule.as_ref()
  360    360   
    }
  361    361   
}
  362    362   
static EXPLANATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  363    363   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation", "com.amazonaws.ec2", "Explanation");
  364    364   
static EXPLANATION_MEMBER_ACL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  365    365   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$Acl", "com.amazonaws.ec2", "Explanation"),
  366    366   
    ::aws_smithy_schema::ShapeType::Structure,
  367         -
    "acl",
         367  +
    "Acl",
  368    368   
    0,
  369    369   
)
  370    370   
.with_xml_name("acl");
  371    371   
static EXPLANATION_MEMBER_ACL_RULE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  372    372   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$AclRule", "com.amazonaws.ec2", "Explanation"),
  373    373   
    ::aws_smithy_schema::ShapeType::Structure,
  374         -
    "acl_rule",
         374  +
    "AclRule",
  375    375   
    1,
  376    376   
)
  377    377   
.with_xml_name("aclRule");
  378    378   
static EXPLANATION_MEMBER_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  379    379   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$Address", "com.amazonaws.ec2", "Explanation"),
  380    380   
    ::aws_smithy_schema::ShapeType::String,
  381         -
    "address",
         381  +
    "Address",
  382    382   
    2,
  383    383   
)
  384    384   
.with_xml_name("address");
  385    385   
static EXPLANATION_MEMBER_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  386    386   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$Addresses", "com.amazonaws.ec2", "Explanation"),
  387    387   
    ::aws_smithy_schema::ShapeType::List,
  388         -
    "addresses",
         388  +
    "Addresses",
  389    389   
    3,
  390    390   
)
  391    391   
.with_xml_name("addressSet");
  392    392   
static EXPLANATION_MEMBER_ATTACHED_TO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  393    393   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$AttachedTo", "com.amazonaws.ec2", "Explanation"),
  394    394   
    ::aws_smithy_schema::ShapeType::Structure,
  395         -
    "attached_to",
         395  +
    "AttachedTo",
  396    396   
    4,
  397    397   
)
  398    398   
.with_xml_name("attachedTo");
  399    399   
static EXPLANATION_MEMBER_AVAILABILITY_ZONES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  400    400   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$AvailabilityZones", "com.amazonaws.ec2", "Explanation"),
  401    401   
    ::aws_smithy_schema::ShapeType::List,
  402         -
    "availability_zones",
         402  +
    "AvailabilityZones",
  403    403   
    5,
  404    404   
)
  405    405   
.with_xml_name("availabilityZoneSet");
  406    406   
static EXPLANATION_MEMBER_AVAILABILITY_ZONE_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  407    407   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$AvailabilityZoneIds", "com.amazonaws.ec2", "Explanation"),
  408    408   
    ::aws_smithy_schema::ShapeType::List,
  409         -
    "availability_zone_ids",
         409  +
    "AvailabilityZoneIds",
  410    410   
    6,
  411    411   
)
  412    412   
.with_xml_name("availabilityZoneIdSet");
  413    413   
static EXPLANATION_MEMBER_CIDRS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  414    414   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$Cidrs", "com.amazonaws.ec2", "Explanation"),
  415    415   
    ::aws_smithy_schema::ShapeType::List,
  416         -
    "cidrs",
         416  +
    "Cidrs",
  417    417   
    7,
  418    418   
)
  419    419   
.with_xml_name("cidrSet");
  420    420   
static EXPLANATION_MEMBER_COMPONENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  421    421   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$Component", "com.amazonaws.ec2", "Explanation"),
  422    422   
    ::aws_smithy_schema::ShapeType::Structure,
  423         -
    "component",
         423  +
    "Component",
  424    424   
    8,
  425    425   
)
  426    426   
.with_xml_name("component");
  427    427   
static EXPLANATION_MEMBER_CUSTOMER_GATEWAY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  428    428   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$CustomerGateway", "com.amazonaws.ec2", "Explanation"),
  429    429   
    ::aws_smithy_schema::ShapeType::Structure,
  430         -
    "customer_gateway",
         430  +
    "CustomerGateway",
  431    431   
    9,
  432    432   
)
  433    433   
.with_xml_name("customerGateway");
  434    434   
static EXPLANATION_MEMBER_DESTINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  435    435   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$Destination", "com.amazonaws.ec2", "Explanation"),
  436    436   
    ::aws_smithy_schema::ShapeType::Structure,
  437         -
    "destination",
         437  +
    "Destination",
  438    438   
    10,
  439    439   
)
  440    440   
.with_xml_name("destination");
  441    441   
static EXPLANATION_MEMBER_DESTINATION_VPC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  442    442   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$DestinationVpc", "com.amazonaws.ec2", "Explanation"),
  443    443   
    ::aws_smithy_schema::ShapeType::Structure,
  444         -
    "destination_vpc",
         444  +
    "DestinationVpc",
  445    445   
    11,
  446    446   
)
  447    447   
.with_xml_name("destinationVpc");
  448    448   
static EXPLANATION_MEMBER_DIRECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  449    449   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$Direction", "com.amazonaws.ec2", "Explanation"),
  450    450   
    ::aws_smithy_schema::ShapeType::String,
  451         -
    "direction",
         451  +
    "Direction",
  452    452   
    12,
  453    453   
)
  454    454   
.with_xml_name("direction");
  455    455   
static EXPLANATION_MEMBER_EXPLANATION_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  456    456   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$ExplanationCode", "com.amazonaws.ec2", "Explanation"),
  457    457   
    ::aws_smithy_schema::ShapeType::String,
  458         -
    "explanation_code",
         458  +
    "ExplanationCode",
  459    459   
    13,
  460    460   
)
  461    461   
.with_xml_name("explanationCode");
  462    462   
static EXPLANATION_MEMBER_INGRESS_ROUTE_TABLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  463    463   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$IngressRouteTable", "com.amazonaws.ec2", "Explanation"),
  464    464   
    ::aws_smithy_schema::ShapeType::Structure,
  465         -
    "ingress_route_table",
         465  +
    "IngressRouteTable",
  466    466   
    14,
  467    467   
)
  468    468   
.with_xml_name("ingressRouteTable");
  469    469   
static EXPLANATION_MEMBER_INTERNET_GATEWAY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  470    470   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$InternetGateway", "com.amazonaws.ec2", "Explanation"),
  471    471   
    ::aws_smithy_schema::ShapeType::Structure,
  472         -
    "internet_gateway",
         472  +
    "InternetGateway",
  473    473   
    15,
  474    474   
)
  475    475   
.with_xml_name("internetGateway");
  476    476   
static EXPLANATION_MEMBER_LOAD_BALANCER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  477    477   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$LoadBalancerArn", "com.amazonaws.ec2", "Explanation"),
  478    478   
    ::aws_smithy_schema::ShapeType::String,
  479         -
    "load_balancer_arn",
         479  +
    "LoadBalancerArn",
  480    480   
    16,
  481    481   
)
  482    482   
.with_xml_name("loadBalancerArn");
  483    483   
static EXPLANATION_MEMBER_CLASSIC_LOAD_BALANCER_LISTENER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  484    484   
    ::aws_smithy_schema::ShapeId::from_static(
  485    485   
        "com.amazonaws.ec2#Explanation$ClassicLoadBalancerListener",
  486    486   
        "com.amazonaws.ec2",
  487    487   
        "Explanation",
  488    488   
    ),
  489    489   
    ::aws_smithy_schema::ShapeType::Structure,
  490         -
    "classic_load_balancer_listener",
         490  +
    "ClassicLoadBalancerListener",
  491    491   
    17,
  492    492   
)
  493    493   
.with_xml_name("classicLoadBalancerListener");
  494    494   
static EXPLANATION_MEMBER_LOAD_BALANCER_LISTENER_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  495    495   
    ::aws_smithy_schema::ShapeId::from_static(
  496    496   
        "com.amazonaws.ec2#Explanation$LoadBalancerListenerPort",
  497    497   
        "com.amazonaws.ec2",
  498    498   
        "Explanation",
  499    499   
    ),
  500    500   
    ::aws_smithy_schema::ShapeType::Integer,
  501         -
    "load_balancer_listener_port",
         501  +
    "LoadBalancerListenerPort",
  502    502   
    18,
  503    503   
)
  504    504   
.with_xml_name("loadBalancerListenerPort");
  505    505   
static EXPLANATION_MEMBER_LOAD_BALANCER_TARGET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  506    506   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$LoadBalancerTarget", "com.amazonaws.ec2", "Explanation"),
  507    507   
    ::aws_smithy_schema::ShapeType::Structure,
  508         -
    "load_balancer_target",
         508  +
    "LoadBalancerTarget",
  509    509   
    19,
  510    510   
)
  511    511   
.with_xml_name("loadBalancerTarget");
  512    512   
static EXPLANATION_MEMBER_LOAD_BALANCER_TARGET_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  513    513   
    ::aws_smithy_schema::ShapeId::from_static(
  514    514   
        "com.amazonaws.ec2#Explanation$LoadBalancerTargetGroup",
  515    515   
        "com.amazonaws.ec2",
  516    516   
        "Explanation",
  517    517   
    ),
  518    518   
    ::aws_smithy_schema::ShapeType::Structure,
  519         -
    "load_balancer_target_group",
         519  +
    "LoadBalancerTargetGroup",
  520    520   
    20,
  521    521   
)
  522    522   
.with_xml_name("loadBalancerTargetGroup");
  523    523   
static EXPLANATION_MEMBER_LOAD_BALANCER_TARGET_GROUPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  524    524   
    ::aws_smithy_schema::ShapeId::from_static(
  525    525   
        "com.amazonaws.ec2#Explanation$LoadBalancerTargetGroups",
  526    526   
        "com.amazonaws.ec2",
  527    527   
        "Explanation",
  528    528   
    ),
  529    529   
    ::aws_smithy_schema::ShapeType::List,
  530         -
    "load_balancer_target_groups",
         530  +
    "LoadBalancerTargetGroups",
  531    531   
    21,
  532    532   
)
  533    533   
.with_xml_name("loadBalancerTargetGroupSet");
  534    534   
static EXPLANATION_MEMBER_LOAD_BALANCER_TARGET_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  535    535   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$LoadBalancerTargetPort", "com.amazonaws.ec2", "Explanation"),
  536    536   
    ::aws_smithy_schema::ShapeType::Integer,
  537         -
    "load_balancer_target_port",
         537  +
    "LoadBalancerTargetPort",
  538    538   
    22,
  539    539   
)
  540    540   
.with_xml_name("loadBalancerTargetPort");
  541    541   
static EXPLANATION_MEMBER_ELASTIC_LOAD_BALANCER_LISTENER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  542    542   
    ::aws_smithy_schema::ShapeId::from_static(
  543    543   
        "com.amazonaws.ec2#Explanation$ElasticLoadBalancerListener",
  544    544   
        "com.amazonaws.ec2",
  545    545   
        "Explanation",
  546    546   
    ),
  547    547   
    ::aws_smithy_schema::ShapeType::Structure,
  548         -
    "elastic_load_balancer_listener",
         548  +
    "ElasticLoadBalancerListener",
  549    549   
    23,
  550    550   
)
  551    551   
.with_xml_name("elasticLoadBalancerListener");
  552    552   
static EXPLANATION_MEMBER_MISSING_COMPONENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  553    553   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$MissingComponent", "com.amazonaws.ec2", "Explanation"),
  554    554   
    ::aws_smithy_schema::ShapeType::String,
  555         -
    "missing_component",
         555  +
    "MissingComponent",
  556    556   
    24,
  557    557   
)
  558    558   
.with_xml_name("missingComponent");
  559    559   
static EXPLANATION_MEMBER_NAT_GATEWAY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  560    560   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$NatGateway", "com.amazonaws.ec2", "Explanation"),
  561    561   
    ::aws_smithy_schema::ShapeType::Structure,
  562         -
    "nat_gateway",
         562  +
    "NatGateway",
  563    563   
    25,
  564    564   
)
  565    565   
.with_xml_name("natGateway");
  566    566   
static EXPLANATION_MEMBER_NETWORK_INTERFACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  567    567   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$NetworkInterface", "com.amazonaws.ec2", "Explanation"),
  568    568   
    ::aws_smithy_schema::ShapeType::Structure,
  569         -
    "network_interface",
         569  +
    "NetworkInterface",
  570    570   
    26,
  571    571   
)
  572    572   
.with_xml_name("networkInterface");
  573    573   
static EXPLANATION_MEMBER_PACKET_FIELD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  574    574   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$PacketField", "com.amazonaws.ec2", "Explanation"),
  575    575   
    ::aws_smithy_schema::ShapeType::String,
  576         -
    "packet_field",
         576  +
    "PacketField",
  577    577   
    27,
  578    578   
)
  579    579   
.with_xml_name("packetField");
  580    580   
static EXPLANATION_MEMBER_VPC_PEERING_CONNECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  581    581   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$VpcPeeringConnection", "com.amazonaws.ec2", "Explanation"),
  582    582   
    ::aws_smithy_schema::ShapeType::Structure,
  583         -
    "vpc_peering_connection",
         583  +
    "VpcPeeringConnection",
  584    584   
    28,
  585    585   
)
  586    586   
.with_xml_name("vpcPeeringConnection");
  587    587   
static EXPLANATION_MEMBER_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  588    588   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$Port", "com.amazonaws.ec2", "Explanation"),
  589    589   
    ::aws_smithy_schema::ShapeType::Integer,
  590         -
    "port",
         590  +
    "Port",
  591    591   
    29,
  592    592   
)
  593    593   
.with_xml_name("port");
  594    594   
static EXPLANATION_MEMBER_PORT_RANGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  595    595   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$PortRanges", "com.amazonaws.ec2", "Explanation"),
  596    596   
    ::aws_smithy_schema::ShapeType::List,
  597         -
    "port_ranges",
         597  +
    "PortRanges",
  598    598   
    30,
  599    599   
)
  600    600   
.with_xml_name("portRangeSet");
  601    601   
static EXPLANATION_MEMBER_PREFIX_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  602    602   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$PrefixList", "com.amazonaws.ec2", "Explanation"),
  603    603   
    ::aws_smithy_schema::ShapeType::Structure,
  604         -
    "prefix_list",
         604  +
    "PrefixList",
  605    605   
    31,
  606    606   
)
  607    607   
.with_xml_name("prefixList");
  608    608   
static EXPLANATION_MEMBER_PROTOCOLS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  609    609   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$Protocols", "com.amazonaws.ec2", "Explanation"),
  610    610   
    ::aws_smithy_schema::ShapeType::List,
  611         -
    "protocols",
         611  +
    "Protocols",
  612    612   
    32,
  613    613   
)
  614    614   
.with_xml_name("protocolSet");
  615    615   
static EXPLANATION_MEMBER_ROUTE_TABLE_ROUTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  616    616   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$RouteTableRoute", "com.amazonaws.ec2", "Explanation"),
  617    617   
    ::aws_smithy_schema::ShapeType::Structure,
  618         -
    "route_table_route",
         618  +
    "RouteTableRoute",
  619    619   
    33,
  620    620   
)
  621    621   
.with_xml_name("routeTableRoute");
  622    622   
static EXPLANATION_MEMBER_ROUTE_TABLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  623    623   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$RouteTable", "com.amazonaws.ec2", "Explanation"),
  624    624   
    ::aws_smithy_schema::ShapeType::Structure,
  625         -
    "route_table",
         625  +
    "RouteTable",
  626    626   
    34,
  627    627   
)
  628    628   
.with_xml_name("routeTable");
  629    629   
static EXPLANATION_MEMBER_SECURITY_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  630    630   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$SecurityGroup", "com.amazonaws.ec2", "Explanation"),
  631    631   
    ::aws_smithy_schema::ShapeType::Structure,
  632         -
    "security_group",
         632  +
    "SecurityGroup",
  633    633   
    35,
  634    634   
)
  635    635   
.with_xml_name("securityGroup");
  636    636   
static EXPLANATION_MEMBER_SECURITY_GROUP_RULE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  637    637   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$SecurityGroupRule", "com.amazonaws.ec2", "Explanation"),
  638    638   
    ::aws_smithy_schema::ShapeType::Structure,
  639         -
    "security_group_rule",
         639  +
    "SecurityGroupRule",
  640    640   
    36,
  641    641   
)
  642    642   
.with_xml_name("securityGroupRule");
  643    643   
static EXPLANATION_MEMBER_SECURITY_GROUPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  644    644   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$SecurityGroups", "com.amazonaws.ec2", "Explanation"),
  645    645   
    ::aws_smithy_schema::ShapeType::List,
  646         -
    "security_groups",
         646  +
    "SecurityGroups",
  647    647   
    37,
  648    648   
)
  649    649   
.with_xml_name("securityGroupSet");
  650    650   
static EXPLANATION_MEMBER_SOURCE_VPC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  651    651   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$SourceVpc", "com.amazonaws.ec2", "Explanation"),
  652    652   
    ::aws_smithy_schema::ShapeType::Structure,
  653         -
    "source_vpc",
         653  +
    "SourceVpc",
  654    654   
    38,
  655    655   
)
  656    656   
.with_xml_name("sourceVpc");
  657    657   
static EXPLANATION_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  658    658   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$State", "com.amazonaws.ec2", "Explanation"),
  659    659   
    ::aws_smithy_schema::ShapeType::String,
  660         -
    "state",
         660  +
    "State",
  661    661   
    39,
  662    662   
)
  663    663   
.with_xml_name("state");
  664    664   
static EXPLANATION_MEMBER_SUBNET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  665    665   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$Subnet", "com.amazonaws.ec2", "Explanation"),
  666    666   
    ::aws_smithy_schema::ShapeType::Structure,
  667         -
    "subnet",
         667  +
    "Subnet",
  668    668   
    40,
  669    669   
)
  670    670   
.with_xml_name("subnet");
  671    671   
static EXPLANATION_MEMBER_SUBNET_ROUTE_TABLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  672    672   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$SubnetRouteTable", "com.amazonaws.ec2", "Explanation"),
  673    673   
    ::aws_smithy_schema::ShapeType::Structure,
  674         -
    "subnet_route_table",
         674  +
    "SubnetRouteTable",
  675    675   
    41,
  676    676   
)
  677    677   
.with_xml_name("subnetRouteTable");
  678    678   
static EXPLANATION_MEMBER_VPC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  679    679   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$Vpc", "com.amazonaws.ec2", "Explanation"),
  680    680   
    ::aws_smithy_schema::ShapeType::Structure,
  681         -
    "vpc",
         681  +
    "Vpc",
  682    682   
    42,
  683    683   
)
  684    684   
.with_xml_name("vpc");
  685    685   
static EXPLANATION_MEMBER_VPC_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  686    686   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$VpcEndpoint", "com.amazonaws.ec2", "Explanation"),
  687    687   
    ::aws_smithy_schema::ShapeType::Structure,
  688         -
    "vpc_endpoint",
         688  +
    "VpcEndpoint",
  689    689   
    43,
  690    690   
)
  691    691   
.with_xml_name("vpcEndpoint");
  692    692   
static EXPLANATION_MEMBER_VPN_CONNECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  693    693   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$VpnConnection", "com.amazonaws.ec2", "Explanation"),
  694    694   
    ::aws_smithy_schema::ShapeType::Structure,
  695         -
    "vpn_connection",
         695  +
    "VpnConnection",
  696    696   
    44,
  697    697   
)
  698    698   
.with_xml_name("vpnConnection");
  699    699   
static EXPLANATION_MEMBER_VPN_GATEWAY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  700    700   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$VpnGateway", "com.amazonaws.ec2", "Explanation"),
  701    701   
    ::aws_smithy_schema::ShapeType::Structure,
  702         -
    "vpn_gateway",
         702  +
    "VpnGateway",
  703    703   
    45,
  704    704   
)
  705    705   
.with_xml_name("vpnGateway");
  706    706   
static EXPLANATION_MEMBER_TRANSIT_GATEWAY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  707    707   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$TransitGateway", "com.amazonaws.ec2", "Explanation"),
  708    708   
    ::aws_smithy_schema::ShapeType::Structure,
  709         -
    "transit_gateway",
         709  +
    "TransitGateway",
  710    710   
    46,
  711    711   
)
  712    712   
.with_xml_name("transitGateway");
  713    713   
static EXPLANATION_MEMBER_TRANSIT_GATEWAY_ROUTE_TABLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  714    714   
    ::aws_smithy_schema::ShapeId::from_static(
  715    715   
        "com.amazonaws.ec2#Explanation$TransitGatewayRouteTable",
  716    716   
        "com.amazonaws.ec2",
  717    717   
        "Explanation",
  718    718   
    ),
  719    719   
    ::aws_smithy_schema::ShapeType::Structure,
  720         -
    "transit_gateway_route_table",
         720  +
    "TransitGatewayRouteTable",
  721    721   
    47,
  722    722   
)
  723    723   
.with_xml_name("transitGatewayRouteTable");
  724    724   
static EXPLANATION_MEMBER_TRANSIT_GATEWAY_ROUTE_TABLE_ROUTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  725    725   
    ::aws_smithy_schema::ShapeId::from_static(
  726    726   
        "com.amazonaws.ec2#Explanation$TransitGatewayRouteTableRoute",
  727    727   
        "com.amazonaws.ec2",
  728    728   
        "Explanation",
  729    729   
    ),
  730    730   
    ::aws_smithy_schema::ShapeType::Structure,
  731         -
    "transit_gateway_route_table_route",
         731  +
    "TransitGatewayRouteTableRoute",
  732    732   
    48,
  733    733   
)
  734    734   
.with_xml_name("transitGatewayRouteTableRoute");
  735    735   
static EXPLANATION_MEMBER_TRANSIT_GATEWAY_ATTACHMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  736    736   
    ::aws_smithy_schema::ShapeId::from_static(
  737    737   
        "com.amazonaws.ec2#Explanation$TransitGatewayAttachment",
  738    738   
        "com.amazonaws.ec2",
  739    739   
        "Explanation",
  740    740   
    ),
  741    741   
    ::aws_smithy_schema::ShapeType::Structure,
  742         -
    "transit_gateway_attachment",
         742  +
    "TransitGatewayAttachment",
  743    743   
    49,
  744    744   
)
  745    745   
.with_xml_name("transitGatewayAttachment");
  746    746   
static EXPLANATION_MEMBER_COMPONENT_ACCOUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  747    747   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$ComponentAccount", "com.amazonaws.ec2", "Explanation"),
  748    748   
    ::aws_smithy_schema::ShapeType::String,
  749         -
    "component_account",
         749  +
    "ComponentAccount",
  750    750   
    50,
  751    751   
)
  752    752   
.with_xml_name("componentAccount");
  753    753   
static EXPLANATION_MEMBER_COMPONENT_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  754    754   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$ComponentRegion", "com.amazonaws.ec2", "Explanation"),
  755    755   
    ::aws_smithy_schema::ShapeType::String,
  756         -
    "component_region",
         756  +
    "ComponentRegion",
  757    757   
    51,
  758    758   
)
  759    759   
.with_xml_name("componentRegion");
  760    760   
static EXPLANATION_MEMBER_FIREWALL_STATELESS_RULE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  761    761   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$FirewallStatelessRule", "com.amazonaws.ec2", "Explanation"),
  762    762   
    ::aws_smithy_schema::ShapeType::Structure,
  763         -
    "firewall_stateless_rule",
         763  +
    "FirewallStatelessRule",
  764    764   
    52,
  765    765   
)
  766    766   
.with_xml_name("firewallStatelessRule");
  767    767   
static EXPLANATION_MEMBER_FIREWALL_STATEFUL_RULE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  768    768   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Explanation$FirewallStatefulRule", "com.amazonaws.ec2", "Explanation"),
  769    769   
    ::aws_smithy_schema::ShapeType::Structure,
  770         -
    "firewall_stateful_rule",
         770  +
    "FirewallStatefulRule",
  771    771   
    53,
  772    772   
)
  773    773   
.with_xml_name("firewallStatefulRule");
  774    774   
static EXPLANATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  775    775   
    EXPLANATION_SCHEMA_ID,
  776    776   
    ::aws_smithy_schema::ShapeType::Structure,
  777    777   
    &[
  778    778   
        &EXPLANATION_MEMBER_ACL,
  779    779   
        &EXPLANATION_MEMBER_ACL_RULE,
  780    780   
        &EXPLANATION_MEMBER_ADDRESS,
@@ -1042,1042 +1364,1316 @@
 1062   1062   
            ser.write_struct(&EXPLANATION_MEMBER_FIREWALL_STATELESS_RULE, val)?;
 1063   1063   
        }
 1064   1064   
        if let Some(ref val) = self.firewall_stateful_rule {
 1065   1065   
            ser.write_struct(&EXPLANATION_MEMBER_FIREWALL_STATEFUL_RULE, val)?;
 1066   1066   
        }
 1067   1067   
        Ok(())
 1068   1068   
    }
 1069   1069   
}
 1070   1070   
impl Explanation {
 1071   1071   
    /// Deserializes this structure from a [`ShapeDeserializer`].
 1072         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
 1073         -
        deserializer: &mut D,
        1072  +
    pub fn deserialize(
        1073  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
 1074   1074   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
 1075   1075   
        #[allow(unused_variables, unused_mut)]
 1076   1076   
        let mut builder = Self::builder();
 1077   1077   
        #[allow(
 1078   1078   
            unused_variables,
 1079   1079   
            unreachable_code,
 1080   1080   
            clippy::single_match,
 1081   1081   
            clippy::match_single_binding,
 1082   1082   
            clippy::diverging_sub_expression
 1083   1083   
        )]
 1084         -
        deserializer.read_struct(&EXPLANATION_SCHEMA, (), |_, member, deser| {
        1084  +
        deserializer.read_struct(&EXPLANATION_SCHEMA, &mut |member, deser| {
 1085   1085   
            match member.member_index() {
 1086   1086   
                Some(0) => {
 1087   1087   
                    builder.acl = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1088   1088   
                }
 1089   1089   
                Some(1) => {
 1090   1090   
                    builder.acl_rule = Some(crate::types::AnalysisAclRule::deserialize(deser)?);
 1091   1091   
                }
 1092   1092   
                Some(2) => {
 1093   1093   
                    builder.address = Some(deser.read_string(member)?);
 1094   1094   
                }
 1095   1095   
                Some(3) => {
 1096         -
                    builder.addresses = Some({
 1097         -
                        let container = if let Some(cap) = deser.container_size() {
 1098         -
                            Vec::with_capacity(cap)
 1099         -
                        } else {
 1100         -
                            Vec::new()
 1101         -
                        };
 1102         -
                        deser.read_list(member, container, |mut list, deser| {
 1103         -
                            list.push(deser.read_string(member)?);
 1104         -
                            Ok(list)
 1105         -
                        })?
 1106         -
                    });
        1096  +
                    builder.addresses = Some(deser.read_string_list(member)?);
 1107   1097   
                }
 1108   1098   
                Some(4) => {
 1109   1099   
                    builder.attached_to = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1110   1100   
                }
 1111   1101   
                Some(5) => {
 1112         -
                    builder.availability_zones = Some({
 1113         -
                        let container = if let Some(cap) = deser.container_size() {
 1114         -
                            Vec::with_capacity(cap)
 1115         -
                        } else {
 1116         -
                            Vec::new()
 1117         -
                        };
 1118         -
                        deser.read_list(member, container, |mut list, deser| {
 1119         -
                            list.push(deser.read_string(member)?);
 1120         -
                            Ok(list)
 1121         -
                        })?
 1122         -
                    });
        1102  +
                    builder.availability_zones = Some(deser.read_string_list(member)?);
 1123   1103   
                }
 1124   1104   
                Some(6) => {
 1125         -
                    builder.availability_zone_ids = Some({
 1126         -
                        let container = if let Some(cap) = deser.container_size() {
 1127         -
                            Vec::with_capacity(cap)
 1128         -
                        } else {
 1129         -
                            Vec::new()
 1130         -
                        };
 1131         -
                        deser.read_list(member, container, |mut list, deser| {
 1132         -
                            list.push(deser.read_string(member)?);
 1133         -
                            Ok(list)
 1134         -
                        })?
 1135         -
                    });
        1105  +
                    builder.availability_zone_ids = Some(deser.read_string_list(member)?);
 1136   1106   
                }
 1137   1107   
                Some(7) => {
 1138         -
                    builder.cidrs = Some({
 1139         -
                        let container = if let Some(cap) = deser.container_size() {
 1140         -
                            Vec::with_capacity(cap)
 1141         -
                        } else {
 1142         -
                            Vec::new()
 1143         -
                        };
 1144         -
                        deser.read_list(member, container, |mut list, deser| {
 1145         -
                            list.push(deser.read_string(member)?);
 1146         -
                            Ok(list)
 1147         -
                        })?
 1148         -
                    });
        1108  +
                    builder.cidrs = Some(deser.read_string_list(member)?);
 1149   1109   
                }
 1150   1110   
                Some(8) => {
 1151   1111   
                    builder.component = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1152   1112   
                }
 1153   1113   
                Some(9) => {
 1154   1114   
                    builder.customer_gateway = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1155   1115   
                }
 1156   1116   
                Some(10) => {
 1157   1117   
                    builder.destination = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1158   1118   
                }
 1159   1119   
                Some(11) => {
 1160   1120   
                    builder.destination_vpc = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1161   1121   
                }
 1162   1122   
                Some(12) => {
 1163   1123   
                    builder.direction = Some(deser.read_string(member)?);
 1164   1124   
                }
 1165   1125   
                Some(13) => {
 1166   1126   
                    builder.explanation_code = Some(deser.read_string(member)?);
 1167   1127   
                }
 1168   1128   
                Some(14) => {
 1169   1129   
                    builder.ingress_route_table = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1170   1130   
                }
 1171   1131   
                Some(15) => {
 1172   1132   
                    builder.internet_gateway = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1173   1133   
                }
 1174   1134   
                Some(16) => {
 1175   1135   
                    builder.load_balancer_arn = Some(deser.read_string(member)?);
 1176   1136   
                }
 1177   1137   
                Some(17) => {
 1178   1138   
                    builder.classic_load_balancer_listener = Some(crate::types::AnalysisLoadBalancerListener::deserialize(deser)?);
 1179   1139   
                }
 1180   1140   
                Some(18) => {
 1181   1141   
                    builder.load_balancer_listener_port = Some(deser.read_integer(member)?);
 1182   1142   
                }
 1183   1143   
                Some(19) => {
 1184   1144   
                    builder.load_balancer_target = Some(crate::types::AnalysisLoadBalancerTarget::deserialize(deser)?);
 1185   1145   
                }
 1186   1146   
                Some(20) => {
 1187   1147   
                    builder.load_balancer_target_group = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1188   1148   
                }
 1189   1149   
                Some(21) => {
 1190   1150   
                    builder.load_balancer_target_groups = Some({
 1191         -
                        let container = if let Some(cap) = deser.container_size() {
 1192         -
                            Vec::with_capacity(cap)
 1193         -
                        } else {
 1194         -
                            Vec::new()
 1195         -
                        };
 1196         -
                        deser.read_list(member, container, |mut list, deser| {
 1197         -
                            list.push(crate::types::AnalysisComponent::deserialize(deser)?);
 1198         -
                            Ok(list)
 1199         -
                        })?
        1151  +
                        let mut container = Vec::new();
        1152  +
                        deser.read_list(member, &mut |deser| {
        1153  +
                            container.push(crate::types::AnalysisComponent::deserialize(deser)?);
        1154  +
                            Ok(())
        1155  +
                        })?;
        1156  +
                        container
 1200   1157   
                    });
 1201   1158   
                }
 1202   1159   
                Some(22) => {
 1203   1160   
                    builder.load_balancer_target_port = Some(deser.read_integer(member)?);
 1204   1161   
                }
 1205   1162   
                Some(23) => {
 1206   1163   
                    builder.elastic_load_balancer_listener = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1207   1164   
                }
 1208   1165   
                Some(24) => {
 1209   1166   
                    builder.missing_component = Some(deser.read_string(member)?);
 1210   1167   
                }
 1211   1168   
                Some(25) => {
 1212   1169   
                    builder.nat_gateway = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1213   1170   
                }
 1214   1171   
                Some(26) => {
 1215   1172   
                    builder.network_interface = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1216   1173   
                }
 1217   1174   
                Some(27) => {
 1218   1175   
                    builder.packet_field = Some(deser.read_string(member)?);
 1219   1176   
                }
 1220   1177   
                Some(28) => {
 1221   1178   
                    builder.vpc_peering_connection = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1222   1179   
                }
 1223   1180   
                Some(29) => {
 1224   1181   
                    builder.port = Some(deser.read_integer(member)?);
 1225   1182   
                }
 1226   1183   
                Some(30) => {
 1227   1184   
                    builder.port_ranges = Some({
 1228         -
                        let container = if let Some(cap) = deser.container_size() {
 1229         -
                            Vec::with_capacity(cap)
 1230         -
                        } else {
 1231         -
                            Vec::new()
 1232         -
                        };
 1233         -
                        deser.read_list(member, container, |mut list, deser| {
 1234         -
                            list.push(crate::types::PortRange::deserialize(deser)?);
 1235         -
                            Ok(list)
 1236         -
                        })?
        1185  +
                        let mut container = Vec::new();
        1186  +
                        deser.read_list(member, &mut |deser| {
        1187  +
                            container.push(crate::types::PortRange::deserialize(deser)?);
        1188  +
                            Ok(())
        1189  +
                        })?;
        1190  +
                        container
 1237   1191   
                    });
 1238   1192   
                }
 1239   1193   
                Some(31) => {
 1240   1194   
                    builder.prefix_list = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1241   1195   
                }
 1242   1196   
                Some(32) => {
 1243         -
                    builder.protocols = Some({
 1244         -
                        let container = if let Some(cap) = deser.container_size() {
 1245         -
                            Vec::with_capacity(cap)
 1246         -
                        } else {
 1247         -
                            Vec::new()
 1248         -
                        };
 1249         -
                        deser.read_list(member, container, |mut list, deser| {
 1250         -
                            list.push(deser.read_string(member)?);
 1251         -
                            Ok(list)
 1252         -
                        })?
 1253         -
                    });
        1197  +
                    builder.protocols = Some(deser.read_string_list(member)?);
 1254   1198   
                }
 1255   1199   
                Some(33) => {
 1256   1200   
                    builder.route_table_route = Some(crate::types::AnalysisRouteTableRoute::deserialize(deser)?);
 1257   1201   
                }
 1258   1202   
                Some(34) => {
 1259   1203   
                    builder.route_table = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1260   1204   
                }
 1261   1205   
                Some(35) => {
 1262   1206   
                    builder.security_group = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1263   1207   
                }
 1264   1208   
                Some(36) => {
 1265   1209   
                    builder.security_group_rule = Some(crate::types::AnalysisSecurityGroupRule::deserialize(deser)?);
 1266   1210   
                }
 1267   1211   
                Some(37) => {
 1268   1212   
                    builder.security_groups = Some({
 1269         -
                        let container = if let Some(cap) = deser.container_size() {
 1270         -
                            Vec::with_capacity(cap)
 1271         -
                        } else {
 1272         -
                            Vec::new()
 1273         -
                        };
 1274         -
                        deser.read_list(member, container, |mut list, deser| {
 1275         -
                            list.push(crate::types::AnalysisComponent::deserialize(deser)?);
 1276         -
                            Ok(list)
 1277         -
                        })?
        1213  +
                        let mut container = Vec::new();
        1214  +
                        deser.read_list(member, &mut |deser| {
        1215  +
                            container.push(crate::types::AnalysisComponent::deserialize(deser)?);
        1216  +
                            Ok(())
        1217  +
                        })?;
        1218  +
                        container
 1278   1219   
                    });
 1279   1220   
                }
 1280   1221   
                Some(38) => {
 1281   1222   
                    builder.source_vpc = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1282   1223   
                }
 1283   1224   
                Some(39) => {
 1284   1225   
                    builder.state = Some(deser.read_string(member)?);
 1285   1226   
                }
 1286   1227   
                Some(40) => {
 1287   1228   
                    builder.subnet = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1288   1229   
                }
 1289   1230   
                Some(41) => {
 1290   1231   
                    builder.subnet_route_table = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1291   1232   
                }
 1292   1233   
                Some(42) => {
 1293   1234   
                    builder.vpc = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1294   1235   
                }
 1295   1236   
                Some(43) => {
 1296   1237   
                    builder.vpc_endpoint = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1297   1238   
                }
 1298   1239   
                Some(44) => {
 1299   1240   
                    builder.vpn_connection = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1300   1241   
                }
 1301   1242   
                Some(45) => {
 1302   1243   
                    builder.vpn_gateway = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1303   1244   
                }
 1304   1245   
                Some(46) => {
 1305   1246   
                    builder.transit_gateway = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1306   1247   
                }
 1307   1248   
                Some(47) => {
 1308   1249   
                    builder.transit_gateway_route_table = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1309   1250   
                }
 1310   1251   
                Some(48) => {
 1311   1252   
                    builder.transit_gateway_route_table_route = Some(crate::types::TransitGatewayRouteTableRoute::deserialize(deser)?);
 1312   1253   
                }
 1313   1254   
                Some(49) => {
 1314   1255   
                    builder.transit_gateway_attachment = Some(crate::types::AnalysisComponent::deserialize(deser)?);
 1315   1256   
                }
 1316   1257   
                Some(50) => {
 1317   1258   
                    builder.component_account = Some(deser.read_string(member)?);
 1318   1259   
                }
 1319   1260   
                Some(51) => {
 1320   1261   
                    builder.component_region = Some(deser.read_string(member)?);
 1321   1262   
                }
 1322   1263   
                Some(52) => {
 1323   1264   
                    builder.firewall_stateless_rule = Some(crate::types::FirewallStatelessRule::deserialize(deser)?);
 1324   1265   
                }
 1325   1266   
                Some(53) => {
 1326   1267   
                    builder.firewall_stateful_rule = Some(crate::types::FirewallStatefulRule::deserialize(deser)?);
 1327   1268   
                }
 1328   1269   
                _ => {}
 1329   1270   
            }
 1330   1271   
            Ok(())
 1331   1272   
        })?;
 1332   1273   
        Ok(builder.build())
 1333   1274   
    }
 1334   1275   
}
        1276  +
impl Explanation {
        1277  +
    /// Deserializes this structure from a body deserializer and HTTP response.
        1278  +
    pub fn deserialize_with_response(
        1279  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
        1280  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
        1281  +
        _status: u16,
        1282  +
        _body: &[u8],
        1283  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
        1284  +
        Self::deserialize(deserializer)
        1285  +
    }
        1286  +
}
 1335   1287   
impl Explanation {
 1336   1288   
    /// Creates a new builder-style object to manufacture [`Explanation`](crate::types::Explanation).
 1337   1289   
    pub fn builder() -> crate::types::builders::ExplanationBuilder {
 1338   1290   
        crate::types::builders::ExplanationBuilder::default()
 1339   1291   
    }
 1340   1292   
}
 1341   1293   
 1342   1294   
/// A builder for [`Explanation`](crate::types::Explanation).
 1343   1295   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 1344   1296   
#[non_exhaustive]

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

@@ -35,35 +152,152 @@
   55     55   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
   56     56   
    pub fn tags(&self) -> &[crate::types::Tag] {
   57     57   
        self.tags.as_deref().unwrap_or_default()
   58     58   
    }
   59     59   
}
   60     60   
static EXPORTIMAGETASK_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportImageTask", "com.amazonaws.ec2", "ExportImageTask");
   62     62   
static EXPORTIMAGETASK_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportImageTask$Description", "com.amazonaws.ec2", "ExportImageTask"),
   64     64   
    ::aws_smithy_schema::ShapeType::String,
   65         -
    "description",
          65  +
    "Description",
   66     66   
    0,
   67     67   
)
   68     68   
.with_xml_name("description");
   69     69   
static EXPORTIMAGETASK_MEMBER_EXPORT_IMAGE_TASK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.ec2#ExportImageTask$ExportImageTaskId",
   72     72   
        "com.amazonaws.ec2",
   73     73   
        "ExportImageTask",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "export_image_task_id",
          76  +
    "ExportImageTaskId",
   77     77   
    1,
   78     78   
)
   79     79   
.with_xml_name("exportImageTaskId");
   80     80   
static EXPORTIMAGETASK_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportImageTask$ImageId", "com.amazonaws.ec2", "ExportImageTask"),
   82     82   
    ::aws_smithy_schema::ShapeType::String,
   83         -
    "image_id",
          83  +
    "ImageId",
   84     84   
    2,
   85     85   
)
   86     86   
.with_xml_name("imageId");
   87     87   
static EXPORTIMAGETASK_MEMBER_PROGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportImageTask$Progress", "com.amazonaws.ec2", "ExportImageTask"),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "progress",
          90  +
    "Progress",
   91     91   
    3,
   92     92   
)
   93     93   
.with_xml_name("progress");
   94     94   
static EXPORTIMAGETASK_MEMBER_S3_EXPORT_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static(
   96     96   
        "com.amazonaws.ec2#ExportImageTask$S3ExportLocation",
   97     97   
        "com.amazonaws.ec2",
   98     98   
        "ExportImageTask",
   99     99   
    ),
  100    100   
    ::aws_smithy_schema::ShapeType::Structure,
  101         -
    "s3_export_location",
         101  +
    "S3ExportLocation",
  102    102   
    4,
  103    103   
)
  104    104   
.with_xml_name("s3ExportLocation");
  105    105   
static EXPORTIMAGETASK_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportImageTask$Status", "com.amazonaws.ec2", "ExportImageTask"),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "status",
         108  +
    "Status",
  109    109   
    5,
  110    110   
)
  111    111   
.with_xml_name("status");
  112    112   
static EXPORTIMAGETASK_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportImageTask$StatusMessage", "com.amazonaws.ec2", "ExportImageTask"),
  114    114   
    ::aws_smithy_schema::ShapeType::String,
  115         -
    "status_message",
         115  +
    "StatusMessage",
  116    116   
    6,
  117    117   
)
  118    118   
.with_xml_name("statusMessage");
  119    119   
static EXPORTIMAGETASK_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportImageTask$Tags", "com.amazonaws.ec2", "ExportImageTask"),
  121    121   
    ::aws_smithy_schema::ShapeType::List,
  122         -
    "tags",
         122  +
    "Tags",
  123    123   
    7,
  124    124   
)
  125    125   
.with_xml_name("tagSet");
  126    126   
static EXPORTIMAGETASK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  127    127   
    EXPORTIMAGETASK_SCHEMA_ID,
  128    128   
    ::aws_smithy_schema::ShapeType::Structure,
  129    129   
    &[
  130    130   
        &EXPORTIMAGETASK_MEMBER_DESCRIPTION,
  131    131   
        &EXPORTIMAGETASK_MEMBER_EXPORT_IMAGE_TASK_ID,
  132    132   
        &EXPORTIMAGETASK_MEMBER_IMAGE_ID,
@@ -157,157 +271,279 @@
  177    177   
                    }
  178    178   
                    Ok(())
  179    179   
                },
  180    180   
            )?;
  181    181   
        }
  182    182   
        Ok(())
  183    183   
    }
  184    184   
}
  185    185   
impl ExportImageTask {
  186    186   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  187         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  188         -
        deserializer: &mut D,
         187  +
    pub fn deserialize(
         188  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  189    189   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  190    190   
        #[allow(unused_variables, unused_mut)]
  191    191   
        let mut builder = Self::builder();
  192    192   
        #[allow(
  193    193   
            unused_variables,
  194    194   
            unreachable_code,
  195    195   
            clippy::single_match,
  196    196   
            clippy::match_single_binding,
  197    197   
            clippy::diverging_sub_expression
  198    198   
        )]
  199         -
        deserializer.read_struct(&EXPORTIMAGETASK_SCHEMA, (), |_, member, deser| {
         199  +
        deserializer.read_struct(&EXPORTIMAGETASK_SCHEMA, &mut |member, deser| {
  200    200   
            match member.member_index() {
  201    201   
                Some(0) => {
  202    202   
                    builder.description = Some(deser.read_string(member)?);
  203    203   
                }
  204    204   
                Some(1) => {
  205    205   
                    builder.export_image_task_id = Some(deser.read_string(member)?);
  206    206   
                }
  207    207   
                Some(2) => {
  208    208   
                    builder.image_id = Some(deser.read_string(member)?);
  209    209   
                }
  210    210   
                Some(3) => {
  211    211   
                    builder.progress = Some(deser.read_string(member)?);
  212    212   
                }
  213    213   
                Some(4) => {
  214    214   
                    builder.s3_export_location = Some(crate::types::ExportTaskS3Location::deserialize(deser)?);
  215    215   
                }
  216    216   
                Some(5) => {
  217    217   
                    builder.status = Some(deser.read_string(member)?);
  218    218   
                }
  219    219   
                Some(6) => {
  220    220   
                    builder.status_message = Some(deser.read_string(member)?);
  221    221   
                }
  222    222   
                Some(7) => {
  223    223   
                    builder.tags = Some({
  224         -
                        let container = if let Some(cap) = deser.container_size() {
  225         -
                            Vec::with_capacity(cap)
  226         -
                        } else {
  227         -
                            Vec::new()
  228         -
                        };
  229         -
                        deser.read_list(member, container, |mut list, deser| {
  230         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  231         -
                            Ok(list)
  232         -
                        })?
         224  +
                        let mut container = Vec::new();
         225  +
                        deser.read_list(member, &mut |deser| {
         226  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         227  +
                            Ok(())
         228  +
                        })?;
         229  +
                        container
  233    230   
                    });
  234    231   
                }
  235    232   
                _ => {}
  236    233   
            }
  237    234   
            Ok(())
  238    235   
        })?;
  239    236   
        Ok(builder.build())
  240    237   
    }
  241    238   
}
         239  +
impl ExportImageTask {
         240  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         241  +
    pub fn deserialize_with_response(
         242  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         243  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         244  +
        _status: u16,
         245  +
        _body: &[u8],
         246  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         247  +
        Self::deserialize(deserializer)
         248  +
    }
         249  +
}
  242    250   
impl ExportImageTask {
  243    251   
    /// Creates a new builder-style object to manufacture [`ExportImageTask`](crate::types::ExportImageTask).
  244    252   
    pub fn builder() -> crate::types::builders::ExportImageTaskBuilder {
  245    253   
        crate::types::builders::ExportImageTaskBuilder::default()
  246    254   
    }
  247    255   
}
  248    256   
  249    257   
/// A builder for [`ExportImageTask`](crate::types::ExportImageTask).
  250    258   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  251    259   
#[non_exhaustive]

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

@@ -29,29 +240,248 @@
   49     49   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
   50     50   
    pub fn tags(&self) -> &[crate::types::Tag] {
   51     51   
        self.tags.as_deref().unwrap_or_default()
   52     52   
    }
   53     53   
}
   54     54   
static EXPORTTASK_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportTask", "com.amazonaws.ec2", "ExportTask");
   56     56   
static EXPORTTASK_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportTask$Description", "com.amazonaws.ec2", "ExportTask"),
   58     58   
    ::aws_smithy_schema::ShapeType::String,
   59         -
    "description",
          59  +
    "Description",
   60     60   
    0,
   61     61   
)
   62     62   
.with_xml_name("description");
   63     63   
static EXPORTTASK_MEMBER_EXPORT_TASK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportTask$ExportTaskId", "com.amazonaws.ec2", "ExportTask"),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "export_task_id",
          66  +
    "ExportTaskId",
   67     67   
    1,
   68     68   
)
   69     69   
.with_xml_name("exportTaskId");
   70     70   
static EXPORTTASK_MEMBER_EXPORT_TO_S3_TASK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportTask$ExportToS3Task", "com.amazonaws.ec2", "ExportTask"),
   72     72   
    ::aws_smithy_schema::ShapeType::Structure,
   73         -
    "export_to_s3_task",
          73  +
    "ExportToS3Task",
   74     74   
    2,
   75     75   
)
   76     76   
.with_xml_name("exportToS3");
   77     77   
static EXPORTTASK_MEMBER_INSTANCE_EXPORT_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportTask$InstanceExportDetails", "com.amazonaws.ec2", "ExportTask"),
   79     79   
    ::aws_smithy_schema::ShapeType::Structure,
   80         -
    "instance_export_details",
          80  +
    "InstanceExportDetails",
   81     81   
    3,
   82     82   
)
   83     83   
.with_xml_name("instanceExport");
   84     84   
static EXPORTTASK_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportTask$State", "com.amazonaws.ec2", "ExportTask"),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "state",
          87  +
    "State",
   88     88   
    4,
   89     89   
)
   90     90   
.with_xml_name("state");
   91     91   
static EXPORTTASK_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportTask$StatusMessage", "com.amazonaws.ec2", "ExportTask"),
   93     93   
    ::aws_smithy_schema::ShapeType::String,
   94         -
    "status_message",
          94  +
    "StatusMessage",
   95     95   
    5,
   96     96   
)
   97     97   
.with_xml_name("statusMessage");
   98     98   
static EXPORTTASK_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportTask$Tags", "com.amazonaws.ec2", "ExportTask"),
  100    100   
    ::aws_smithy_schema::ShapeType::List,
  101         -
    "tags",
         101  +
    "Tags",
  102    102   
    6,
  103    103   
)
  104    104   
.with_xml_name("tagSet");
  105    105   
static EXPORTTASK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  106    106   
    EXPORTTASK_SCHEMA_ID,
  107    107   
    ::aws_smithy_schema::ShapeType::Structure,
  108    108   
    &[
  109    109   
        &EXPORTTASK_MEMBER_DESCRIPTION,
  110    110   
        &EXPORTTASK_MEMBER_EXPORT_TASK_ID,
  111    111   
        &EXPORTTASK_MEMBER_EXPORT_TO_S3_TASK,
  112    112   
        &EXPORTTASK_MEMBER_INSTANCE_EXPORT_DETAILS,
  113    113   
        &EXPORTTASK_MEMBER_STATE,
  114    114   
        &EXPORTTASK_MEMBER_STATUS_MESSAGE,
  115    115   
        &EXPORTTASK_MEMBER_TAGS,
  116    116   
    ],
  117    117   
);
  118    118   
impl ExportTask {
  119    119   
    /// The schema for this shape.
  120    120   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXPORTTASK_SCHEMA;
  121    121   
}
  122    122   
impl ::aws_smithy_schema::serde::SerializableStruct for ExportTask {
  123    123   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  124    124   
    fn serialize_members(
  125    125   
        &self,
  126    126   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  127    127   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  128    128   
        if let Some(ref val) = self.description {
  129    129   
            ser.write_string(&EXPORTTASK_MEMBER_DESCRIPTION, val)?;
  130    130   
        }
  131    131   
        if let Some(ref val) = self.export_task_id {
  132    132   
            ser.write_string(&EXPORTTASK_MEMBER_EXPORT_TASK_ID, val)?;
  133    133   
        }
  134    134   
        if let Some(ref val) = self.export_to_s3_task {
  135    135   
            ser.write_struct(&EXPORTTASK_MEMBER_EXPORT_TO_S3_TASK, val)?;
  136    136   
        }
  137    137   
        if let Some(ref val) = self.instance_export_details {
  138    138   
            ser.write_struct(&EXPORTTASK_MEMBER_INSTANCE_EXPORT_DETAILS, val)?;
  139    139   
        }
  140    140   
        if let Some(ref val) = self.state {
  141    141   
            ser.write_string(&EXPORTTASK_MEMBER_STATE, val.as_str())?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.status_message {
  144    144   
            ser.write_string(&EXPORTTASK_MEMBER_STATUS_MESSAGE, val)?;
  145    145   
        }
  146    146   
        if let Some(ref val) = self.tags {
  147    147   
            ser.write_list(&EXPORTTASK_MEMBER_TAGS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  148    148   
                for item in val {
  149    149   
                    ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  150    150   
                }
  151    151   
                Ok(())
  152    152   
            })?;
  153    153   
        }
  154    154   
        Ok(())
  155    155   
    }
  156    156   
}
  157    157   
impl ExportTask {
  158    158   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  159         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  160         -
        deserializer: &mut D,
         159  +
    pub fn deserialize(
         160  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  161    161   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  162    162   
        #[allow(unused_variables, unused_mut)]
  163    163   
        let mut builder = Self::builder();
  164    164   
        #[allow(
  165    165   
            unused_variables,
  166    166   
            unreachable_code,
  167    167   
            clippy::single_match,
  168    168   
            clippy::match_single_binding,
  169    169   
            clippy::diverging_sub_expression
  170    170   
        )]
  171         -
        deserializer.read_struct(&EXPORTTASK_SCHEMA, (), |_, member, deser| {
         171  +
        deserializer.read_struct(&EXPORTTASK_SCHEMA, &mut |member, deser| {
  172    172   
            match member.member_index() {
  173    173   
                Some(0) => {
  174    174   
                    builder.description = Some(deser.read_string(member)?);
  175    175   
                }
  176    176   
                Some(1) => {
  177    177   
                    builder.export_task_id = Some(deser.read_string(member)?);
  178    178   
                }
  179    179   
                Some(2) => {
  180    180   
                    builder.export_to_s3_task = Some(crate::types::ExportToS3Task::deserialize(deser)?);
  181    181   
                }
  182    182   
                Some(3) => {
  183    183   
                    builder.instance_export_details = Some(crate::types::InstanceExportDetails::deserialize(deser)?);
  184    184   
                }
  185    185   
                Some(4) => {
  186    186   
                    builder.state = Some(crate::types::ExportTaskState::from(deser.read_string(member)?.as_str()));
  187    187   
                }
  188    188   
                Some(5) => {
  189    189   
                    builder.status_message = Some(deser.read_string(member)?);
  190    190   
                }
  191    191   
                Some(6) => {
  192    192   
                    builder.tags = Some({
  193         -
                        let container = if let Some(cap) = deser.container_size() {
  194         -
                            Vec::with_capacity(cap)
  195         -
                        } else {
  196         -
                            Vec::new()
  197         -
                        };
  198         -
                        deser.read_list(member, container, |mut list, deser| {
  199         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  200         -
                            Ok(list)
  201         -
                        })?
         193  +
                        let mut container = Vec::new();
         194  +
                        deser.read_list(member, &mut |deser| {
         195  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         196  +
                            Ok(())
         197  +
                        })?;
         198  +
                        container
  202    199   
                    });
  203    200   
                }
  204    201   
                _ => {}
  205    202   
            }
  206    203   
            Ok(())
  207    204   
        })?;
  208    205   
        Ok(builder.build())
  209    206   
    }
  210    207   
}
         208  +
impl ExportTask {
         209  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         210  +
    pub fn deserialize_with_response(
         211  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         212  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         213  +
        _status: u16,
         214  +
        _body: &[u8],
         215  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         216  +
        Self::deserialize(deserializer)
         217  +
    }
         218  +
}
  211    219   
impl ExportTask {
  212    220   
    /// Creates a new builder-style object to manufacture [`ExportTask`](crate::types::ExportTask).
  213    221   
    pub fn builder() -> crate::types::builders::ExportTaskBuilder {
  214    222   
        crate::types::builders::ExportTaskBuilder::default()
  215    223   
    }
  216    224   
}
  217    225   
  218    226   
/// A builder for [`ExportTask`](crate::types::ExportTask).
  219    227   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  220    228   
#[non_exhaustive]

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

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

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

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

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

@@ -9,9 +163,174 @@
   29     29   
    /// <p>The encryption key for your S3 bucket.</p>
   30     30   
    pub fn s3_key(&self) -> ::std::option::Option<&str> {
   31     31   
        self.s3_key.as_deref()
   32     32   
    }
   33     33   
}
   34     34   
static EXPORTTOS3TASK_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   35     35   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportToS3Task", "com.amazonaws.ec2", "ExportToS3Task");
   36     36   
static EXPORTTOS3TASK_MEMBER_CONTAINER_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportToS3Task$ContainerFormat", "com.amazonaws.ec2", "ExportToS3Task"),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "container_format",
          39  +
    "ContainerFormat",
   40     40   
    0,
   41     41   
)
   42     42   
.with_xml_name("containerFormat");
   43     43   
static EXPORTTOS3TASK_MEMBER_DISK_IMAGE_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportToS3Task$DiskImageFormat", "com.amazonaws.ec2", "ExportToS3Task"),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "disk_image_format",
          46  +
    "DiskImageFormat",
   47     47   
    1,
   48     48   
)
   49     49   
.with_xml_name("diskImageFormat");
   50     50   
static EXPORTTOS3TASK_MEMBER_S3_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportToS3Task$S3Bucket", "com.amazonaws.ec2", "ExportToS3Task"),
   52     52   
    ::aws_smithy_schema::ShapeType::String,
   53         -
    "s3_bucket",
          53  +
    "S3Bucket",
   54     54   
    2,
   55     55   
)
   56     56   
.with_xml_name("s3Bucket");
   57     57   
static EXPORTTOS3TASK_MEMBER_S3_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ExportToS3Task$S3Key", "com.amazonaws.ec2", "ExportToS3Task"),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "s3_key",
          60  +
    "S3Key",
   61     61   
    3,
   62     62   
)
   63     63   
.with_xml_name("s3Key");
   64     64   
static EXPORTTOS3TASK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   65     65   
    EXPORTTOS3TASK_SCHEMA_ID,
   66     66   
    ::aws_smithy_schema::ShapeType::Structure,
   67     67   
    &[
   68     68   
        &EXPORTTOS3TASK_MEMBER_CONTAINER_FORMAT,
   69     69   
        &EXPORTTOS3TASK_MEMBER_DISK_IMAGE_FORMAT,
   70     70   
        &EXPORTTOS3TASK_MEMBER_S3_BUCKET,
   71     71   
        &EXPORTTOS3TASK_MEMBER_S3_KEY,
   72     72   
    ],
   73     73   
);
   74     74   
impl ExportToS3Task {
   75     75   
    /// The schema for this shape.
   76     76   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXPORTTOS3TASK_SCHEMA;
   77     77   
}
   78     78   
impl ::aws_smithy_schema::serde::SerializableStruct for ExportToS3Task {
   79     79   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   80     80   
    fn serialize_members(
   81     81   
        &self,
   82     82   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   83     83   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   84     84   
        if let Some(ref val) = self.container_format {
   85     85   
            ser.write_string(&EXPORTTOS3TASK_MEMBER_CONTAINER_FORMAT, val.as_str())?;
   86     86   
        }
   87     87   
        if let Some(ref val) = self.disk_image_format {
   88     88   
            ser.write_string(&EXPORTTOS3TASK_MEMBER_DISK_IMAGE_FORMAT, val.as_str())?;
   89     89   
        }
   90     90   
        if let Some(ref val) = self.s3_bucket {
   91     91   
            ser.write_string(&EXPORTTOS3TASK_MEMBER_S3_BUCKET, val)?;
   92     92   
        }
   93     93   
        if let Some(ref val) = self.s3_key {
   94     94   
            ser.write_string(&EXPORTTOS3TASK_MEMBER_S3_KEY, val)?;
   95     95   
        }
   96     96   
        Ok(())
   97     97   
    }
   98     98   
}
   99     99   
impl ExportToS3Task {
  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(&EXPORTTOS3TASK_SCHEMA, (), |_, member, deser| {
         113  +
        deserializer.read_struct(&EXPORTTOS3TASK_SCHEMA, &mut |member, deser| {
  114    114   
            match member.member_index() {
  115    115   
                Some(0) => {
  116    116   
                    builder.container_format = Some(crate::types::ContainerFormat::from(deser.read_string(member)?.as_str()));
  117    117   
                }
  118    118   
                Some(1) => {
  119    119   
                    builder.disk_image_format = Some(crate::types::DiskImageFormat::from(deser.read_string(member)?.as_str()));
  120    120   
                }
  121    121   
                Some(2) => {
  122    122   
                    builder.s3_bucket = Some(deser.read_string(member)?);
  123    123   
                }
  124    124   
                Some(3) => {
  125    125   
                    builder.s3_key = Some(deser.read_string(member)?);
  126    126   
                }
  127    127   
                _ => {}
  128    128   
            }
  129    129   
            Ok(())
  130    130   
        })?;
  131    131   
        Ok(builder.build())
  132    132   
    }
  133    133   
}
         134  +
impl ExportToS3Task {
         135  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         136  +
    pub fn deserialize_with_response(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         138  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         139  +
        _status: u16,
         140  +
        _body: &[u8],
         141  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         142  +
        Self::deserialize(deserializer)
         143  +
    }
         144  +
}
  134    145   
impl ExportToS3Task {
  135    146   
    /// Creates a new builder-style object to manufacture [`ExportToS3Task`](crate::types::ExportToS3Task).
  136    147   
    pub fn builder() -> crate::types::builders::ExportToS3TaskBuilder {
  137    148   
        crate::types::builders::ExportToS3TaskBuilder::default()
  138    149   
    }
  139    150   
}
  140    151   
  141    152   
/// A builder for [`ExportToS3Task`](crate::types::ExportToS3Task).
  142    153   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  143    154   
#[non_exhaustive]

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

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

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

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