AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406

Files changed:

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

@@ -4,4 +136,147 @@
   24     24   
    "com.amazonaws.ec2",
   25     25   
    "NetworkInterfacePermissionState",
   26     26   
);
   27     27   
static NETWORKINTERFACEPERMISSIONSTATE_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.ec2#NetworkInterfacePermissionState$State",
   30     30   
        "com.amazonaws.ec2",
   31     31   
        "NetworkInterfacePermissionState",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "state",
          34  +
    "State",
   35     35   
    0,
   36     36   
)
   37     37   
.with_xml_name("state");
   38     38   
static NETWORKINTERFACEPERMISSIONSTATE_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.ec2#NetworkInterfacePermissionState$StatusMessage",
   41     41   
        "com.amazonaws.ec2",
   42     42   
        "NetworkInterfacePermissionState",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45         -
    "status_message",
          45  +
    "StatusMessage",
   46     46   
    1,
   47     47   
)
   48     48   
.with_xml_name("statusMessage");
   49     49   
static NETWORKINTERFACEPERMISSIONSTATE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    NETWORKINTERFACEPERMISSIONSTATE_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[
   53     53   
        &NETWORKINTERFACEPERMISSIONSTATE_MEMBER_STATE,
   54     54   
        &NETWORKINTERFACEPERMISSIONSTATE_MEMBER_STATUS_MESSAGE,
   55     55   
    ],
   56     56   
);
   57     57   
impl NetworkInterfacePermissionState {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NETWORKINTERFACEPERMISSIONSTATE_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for NetworkInterfacePermissionState {
   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.state {
   68     68   
            ser.write_string(&NETWORKINTERFACEPERMISSIONSTATE_MEMBER_STATE, val.as_str())?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.status_message {
   71     71   
            ser.write_string(&NETWORKINTERFACEPERMISSIONSTATE_MEMBER_STATUS_MESSAGE, val)?;
   72     72   
        }
   73     73   
        Ok(())
   74     74   
    }
   75     75   
}
   76     76   
impl NetworkInterfacePermissionState {
   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(&NETWORKINTERFACEPERMISSIONSTATE_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&NETWORKINTERFACEPERMISSIONSTATE_SCHEMA, &mut |member, deser| {
   91     91   
            match member.member_index() {
   92     92   
                Some(0) => {
   93     93   
                    builder.state = Some(crate::types::NetworkInterfacePermissionStateCode::from(
   94     94   
                        deser.read_string(member)?.as_str(),
   95     95   
                    ));
   96     96   
                }
   97     97   
                Some(1) => {
   98     98   
                    builder.status_message = Some(deser.read_string(member)?);
   99     99   
                }
  100    100   
                _ => {}
  101    101   
            }
  102    102   
            Ok(())
  103    103   
        })?;
  104    104   
        Ok(builder.build())
  105    105   
    }
  106    106   
}
         107  +
impl NetworkInterfacePermissionState {
         108  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         109  +
    pub fn deserialize_with_response(
         110  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         111  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         112  +
        _status: u16,
         113  +
        _body: &[u8],
         114  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         115  +
        Self::deserialize(deserializer)
         116  +
    }
         117  +
}
  107    118   
impl NetworkInterfacePermissionState {
  108    119   
    /// Creates a new builder-style object to manufacture [`NetworkInterfacePermissionState`](crate::types::NetworkInterfacePermissionState).
  109    120   
    pub fn builder() -> crate::types::builders::NetworkInterfacePermissionStateBuilder {
  110    121   
        crate::types::builders::NetworkInterfacePermissionStateBuilder::default()
  111    122   
    }
  112    123   
}
  113    124   
  114    125   
/// A builder for [`NetworkInterfacePermissionState`](crate::types::NetworkInterfacePermissionState).
  115    126   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  116    127   
#[non_exhaustive]

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

@@ -16,16 +182,193 @@
   36     36   
    "com.amazonaws.ec2",
   37     37   
    "NetworkInterfacePrivateIpAddress",
   38     38   
);
   39     39   
static NETWORKINTERFACEPRIVATEIPADDRESS_MEMBER_ASSOCIATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.ec2#NetworkInterfacePrivateIpAddress$Association",
   42     42   
        "com.amazonaws.ec2",
   43     43   
        "NetworkInterfacePrivateIpAddress",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::Structure,
   46         -
    "association",
          46  +
    "Association",
   47     47   
    0,
   48     48   
)
   49     49   
.with_xml_name("association");
   50     50   
static NETWORKINTERFACEPRIVATEIPADDRESS_MEMBER_PRIMARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.ec2#NetworkInterfacePrivateIpAddress$Primary",
   53     53   
        "com.amazonaws.ec2",
   54     54   
        "NetworkInterfacePrivateIpAddress",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::Boolean,
   57         -
    "primary",
          57  +
    "Primary",
   58     58   
    1,
   59     59   
)
   60     60   
.with_xml_name("primary");
   61     61   
static NETWORKINTERFACEPRIVATEIPADDRESS_MEMBER_PRIVATE_DNS_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.ec2#NetworkInterfacePrivateIpAddress$PrivateDnsName",
   64     64   
        "com.amazonaws.ec2",
   65     65   
        "NetworkInterfacePrivateIpAddress",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::String,
   68         -
    "private_dns_name",
          68  +
    "PrivateDnsName",
   69     69   
    2,
   70     70   
)
   71     71   
.with_xml_name("privateDnsName");
   72     72   
static NETWORKINTERFACEPRIVATEIPADDRESS_MEMBER_PRIVATE_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.ec2#NetworkInterfacePrivateIpAddress$PrivateIpAddress",
   75     75   
        "com.amazonaws.ec2",
   76     76   
        "NetworkInterfacePrivateIpAddress",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "private_ip_address",
          79  +
    "PrivateIpAddress",
   80     80   
    3,
   81     81   
)
   82     82   
.with_xml_name("privateIpAddress");
   83     83   
static NETWORKINTERFACEPRIVATEIPADDRESS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   84     84   
    NETWORKINTERFACEPRIVATEIPADDRESS_SCHEMA_ID,
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86     86   
    &[
   87     87   
        &NETWORKINTERFACEPRIVATEIPADDRESS_MEMBER_ASSOCIATION,
   88     88   
        &NETWORKINTERFACEPRIVATEIPADDRESS_MEMBER_PRIMARY,
   89     89   
        &NETWORKINTERFACEPRIVATEIPADDRESS_MEMBER_PRIVATE_DNS_NAME,
   90     90   
        &NETWORKINTERFACEPRIVATEIPADDRESS_MEMBER_PRIVATE_IP_ADDRESS,
   91     91   
    ],
   92     92   
);
   93     93   
impl NetworkInterfacePrivateIpAddress {
   94     94   
    /// The schema for this shape.
   95     95   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NETWORKINTERFACEPRIVATEIPADDRESS_SCHEMA;
   96     96   
}
   97     97   
impl ::aws_smithy_schema::serde::SerializableStruct for NetworkInterfacePrivateIpAddress {
   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.association {
  104    104   
            ser.write_struct(&NETWORKINTERFACEPRIVATEIPADDRESS_MEMBER_ASSOCIATION, val)?;
  105    105   
        }
  106    106   
        if let Some(ref val) = self.primary {
  107    107   
            ser.write_boolean(&NETWORKINTERFACEPRIVATEIPADDRESS_MEMBER_PRIMARY, *val)?;
  108    108   
        }
  109    109   
        if let Some(ref val) = self.private_dns_name {
  110    110   
            ser.write_string(&NETWORKINTERFACEPRIVATEIPADDRESS_MEMBER_PRIVATE_DNS_NAME, val)?;
  111    111   
        }
  112    112   
        if let Some(ref val) = self.private_ip_address {
  113    113   
            ser.write_string(&NETWORKINTERFACEPRIVATEIPADDRESS_MEMBER_PRIVATE_IP_ADDRESS, val)?;
  114    114   
        }
  115    115   
        Ok(())
  116    116   
    }
  117    117   
}
  118    118   
impl NetworkInterfacePrivateIpAddress {
  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(&NETWORKINTERFACEPRIVATEIPADDRESS_SCHEMA, (), |_, member, deser| {
         132  +
        deserializer.read_struct(&NETWORKINTERFACEPRIVATEIPADDRESS_SCHEMA, &mut |member, deser| {
  133    133   
            match member.member_index() {
  134    134   
                Some(0) => {
  135    135   
                    builder.association = Some(crate::types::NetworkInterfaceAssociation::deserialize(deser)?);
  136    136   
                }
  137    137   
                Some(1) => {
  138    138   
                    builder.primary = Some(deser.read_boolean(member)?);
  139    139   
                }
  140    140   
                Some(2) => {
  141    141   
                    builder.private_dns_name = Some(deser.read_string(member)?);
  142    142   
                }
  143    143   
                Some(3) => {
  144    144   
                    builder.private_ip_address = 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 NetworkInterfacePrivateIpAddress {
         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 NetworkInterfacePrivateIpAddress {
  154    165   
    /// Creates a new builder-style object to manufacture [`NetworkInterfacePrivateIpAddress`](crate::types::NetworkInterfacePrivateIpAddress).
  155    166   
    pub fn builder() -> crate::types::builders::NetworkInterfacePrivateIpAddressBuilder {
  156    167   
        crate::types::builders::NetworkInterfacePrivateIpAddressBuilder::default()
  157    168   
    }
  158    169   
}
  159    170   
  160    171   
/// A builder for [`NetworkInterfacePrivateIpAddress`](crate::types::NetworkInterfacePrivateIpAddress).
  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/_neuron_device_core_info.rs

@@ -1,1 +128,139 @@
   21     21   
}
   22     22   
static NEURONDEVICECOREINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NeuronDeviceCoreInfo", "com.amazonaws.ec2", "NeuronDeviceCoreInfo");
   24     24   
static NEURONDEVICECOREINFO_MEMBER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static(
   26     26   
        "com.amazonaws.ec2#NeuronDeviceCoreInfo$Count",
   27     27   
        "com.amazonaws.ec2",
   28     28   
        "NeuronDeviceCoreInfo",
   29     29   
    ),
   30     30   
    ::aws_smithy_schema::ShapeType::Integer,
   31         -
    "count",
          31  +
    "Count",
   32     32   
    0,
   33     33   
)
   34     34   
.with_xml_name("count");
   35     35   
static NEURONDEVICECOREINFO_MEMBER_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   36     36   
    ::aws_smithy_schema::ShapeId::from_static(
   37     37   
        "com.amazonaws.ec2#NeuronDeviceCoreInfo$Version",
   38     38   
        "com.amazonaws.ec2",
   39     39   
        "NeuronDeviceCoreInfo",
   40     40   
    ),
   41     41   
    ::aws_smithy_schema::ShapeType::Integer,
   42         -
    "version",
          42  +
    "Version",
   43     43   
    1,
   44     44   
)
   45     45   
.with_xml_name("version");
   46     46   
static NEURONDEVICECOREINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   47     47   
    NEURONDEVICECOREINFO_SCHEMA_ID,
   48     48   
    ::aws_smithy_schema::ShapeType::Structure,
   49     49   
    &[&NEURONDEVICECOREINFO_MEMBER_COUNT, &NEURONDEVICECOREINFO_MEMBER_VERSION],
   50     50   
);
   51     51   
impl NeuronDeviceCoreInfo {
   52     52   
    /// The schema for this shape.
   53     53   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NEURONDEVICECOREINFO_SCHEMA;
   54     54   
}
   55     55   
impl ::aws_smithy_schema::serde::SerializableStruct for NeuronDeviceCoreInfo {
   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.count {
   62     62   
            ser.write_integer(&NEURONDEVICECOREINFO_MEMBER_COUNT, *val)?;
   63     63   
        }
   64     64   
        if let Some(ref val) = self.version {
   65     65   
            ser.write_integer(&NEURONDEVICECOREINFO_MEMBER_VERSION, *val)?;
   66     66   
        }
   67     67   
        Ok(())
   68     68   
    }
   69     69   
}
   70     70   
impl NeuronDeviceCoreInfo {
   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(&NEURONDEVICECOREINFO_SCHEMA, (), |_, member, deser| {
          84  +
        deserializer.read_struct(&NEURONDEVICECOREINFO_SCHEMA, &mut |member, deser| {
   85     85   
            match member.member_index() {
   86     86   
                Some(0) => {
   87     87   
                    builder.count = Some(deser.read_integer(member)?);
   88     88   
                }
   89     89   
                Some(1) => {
   90     90   
                    builder.version = Some(deser.read_integer(member)?);
   91     91   
                }
   92     92   
                _ => {}
   93     93   
            }
   94     94   
            Ok(())
   95     95   
        })?;
   96     96   
        Ok(builder.build())
   97     97   
    }
   98     98   
}
          99  +
impl NeuronDeviceCoreInfo {
         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 NeuronDeviceCoreInfo {
  100    111   
    /// Creates a new builder-style object to manufacture [`NeuronDeviceCoreInfo`](crate::types::NeuronDeviceCoreInfo).
  101    112   
    pub fn builder() -> crate::types::builders::NeuronDeviceCoreInfoBuilder {
  102    113   
        crate::types::builders::NeuronDeviceCoreInfoBuilder::default()
  103    114   
    }
  104    115   
}
  105    116   
  106    117   
/// A builder for [`NeuronDeviceCoreInfo`](crate::types::NeuronDeviceCoreInfo).
  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/_neuron_device_info.rs

@@ -9,9 +163,174 @@
   29     29   
    /// <p>Describes the memory available to each neuron accelerator.</p>
   30     30   
    pub fn memory_info(&self) -> ::std::option::Option<&crate::types::NeuronDeviceMemoryInfo> {
   31     31   
        self.memory_info.as_ref()
   32     32   
    }
   33     33   
}
   34     34   
static NEURONDEVICEINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   35     35   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NeuronDeviceInfo", "com.amazonaws.ec2", "NeuronDeviceInfo");
   36     36   
static NEURONDEVICEINFO_MEMBER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NeuronDeviceInfo$Count", "com.amazonaws.ec2", "NeuronDeviceInfo"),
   38     38   
    ::aws_smithy_schema::ShapeType::Integer,
   39         -
    "count",
          39  +
    "Count",
   40     40   
    0,
   41     41   
)
   42     42   
.with_xml_name("count");
   43     43   
static NEURONDEVICEINFO_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NeuronDeviceInfo$Name", "com.amazonaws.ec2", "NeuronDeviceInfo"),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "name",
          46  +
    "Name",
   47     47   
    1,
   48     48   
)
   49     49   
.with_xml_name("name");
   50     50   
static NEURONDEVICEINFO_MEMBER_CORE_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NeuronDeviceInfo$CoreInfo", "com.amazonaws.ec2", "NeuronDeviceInfo"),
   52     52   
    ::aws_smithy_schema::ShapeType::Structure,
   53         -
    "core_info",
          53  +
    "CoreInfo",
   54     54   
    2,
   55     55   
)
   56     56   
.with_xml_name("coreInfo");
   57     57   
static NEURONDEVICEINFO_MEMBER_MEMORY_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NeuronDeviceInfo$MemoryInfo", "com.amazonaws.ec2", "NeuronDeviceInfo"),
   59     59   
    ::aws_smithy_schema::ShapeType::Structure,
   60         -
    "memory_info",
          60  +
    "MemoryInfo",
   61     61   
    3,
   62     62   
)
   63     63   
.with_xml_name("memoryInfo");
   64     64   
static NEURONDEVICEINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   65     65   
    NEURONDEVICEINFO_SCHEMA_ID,
   66     66   
    ::aws_smithy_schema::ShapeType::Structure,
   67     67   
    &[
   68     68   
        &NEURONDEVICEINFO_MEMBER_COUNT,
   69     69   
        &NEURONDEVICEINFO_MEMBER_NAME,
   70     70   
        &NEURONDEVICEINFO_MEMBER_CORE_INFO,
   71     71   
        &NEURONDEVICEINFO_MEMBER_MEMORY_INFO,
   72     72   
    ],
   73     73   
);
   74     74   
impl NeuronDeviceInfo {
   75     75   
    /// The schema for this shape.
   76     76   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NEURONDEVICEINFO_SCHEMA;
   77     77   
}
   78     78   
impl ::aws_smithy_schema::serde::SerializableStruct for NeuronDeviceInfo {
   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.count {
   85     85   
            ser.write_integer(&NEURONDEVICEINFO_MEMBER_COUNT, *val)?;
   86     86   
        }
   87     87   
        if let Some(ref val) = self.name {
   88     88   
            ser.write_string(&NEURONDEVICEINFO_MEMBER_NAME, val)?;
   89     89   
        }
   90     90   
        if let Some(ref val) = self.core_info {
   91     91   
            ser.write_struct(&NEURONDEVICEINFO_MEMBER_CORE_INFO, val)?;
   92     92   
        }
   93     93   
        if let Some(ref val) = self.memory_info {
   94     94   
            ser.write_struct(&NEURONDEVICEINFO_MEMBER_MEMORY_INFO, val)?;
   95     95   
        }
   96     96   
        Ok(())
   97     97   
    }
   98     98   
}
   99     99   
impl NeuronDeviceInfo {
  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(&NEURONDEVICEINFO_SCHEMA, (), |_, member, deser| {
         113  +
        deserializer.read_struct(&NEURONDEVICEINFO_SCHEMA, &mut |member, deser| {
  114    114   
            match member.member_index() {
  115    115   
                Some(0) => {
  116    116   
                    builder.count = Some(deser.read_integer(member)?);
  117    117   
                }
  118    118   
                Some(1) => {
  119    119   
                    builder.name = Some(deser.read_string(member)?);
  120    120   
                }
  121    121   
                Some(2) => {
  122    122   
                    builder.core_info = Some(crate::types::NeuronDeviceCoreInfo::deserialize(deser)?);
  123    123   
                }
  124    124   
                Some(3) => {
  125    125   
                    builder.memory_info = Some(crate::types::NeuronDeviceMemoryInfo::deserialize(deser)?);
  126    126   
                }
  127    127   
                _ => {}
  128    128   
            }
  129    129   
            Ok(())
  130    130   
        })?;
  131    131   
        Ok(builder.build())
  132    132   
    }
  133    133   
}
         134  +
impl NeuronDeviceInfo {
         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 NeuronDeviceInfo {
  135    146   
    /// Creates a new builder-style object to manufacture [`NeuronDeviceInfo`](crate::types::NeuronDeviceInfo).
  136    147   
    pub fn builder() -> crate::types::builders::NeuronDeviceInfoBuilder {
  137    148   
        crate::types::builders::NeuronDeviceInfoBuilder::default()
  138    149   
    }
  139    150   
}
  140    151   
  141    152   
/// A builder for [`NeuronDeviceInfo`](crate::types::NeuronDeviceInfo).
  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/_neuron_device_memory_info.rs

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

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

@@ -1,1 +144,152 @@
   19     19   
    /// <p>The total size of the memory for the neuron accelerators for the instance type, in MiB.</p>
   20     20   
    pub fn total_neuron_device_memory_in_mib(&self) -> ::std::option::Option<i32> {
   21     21   
        self.total_neuron_device_memory_in_mib
   22     22   
    }
   23     23   
}
   24     24   
static NEURONINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NeuronInfo", "com.amazonaws.ec2", "NeuronInfo");
   26     26   
static NEURONINFO_MEMBER_NEURON_DEVICES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NeuronInfo$NeuronDevices", "com.amazonaws.ec2", "NeuronInfo"),
   28     28   
    ::aws_smithy_schema::ShapeType::List,
   29         -
    "neuron_devices",
          29  +
    "NeuronDevices",
   30     30   
    0,
   31     31   
)
   32     32   
.with_xml_name("neuronDevices");
   33     33   
static NEURONINFO_MEMBER_TOTAL_NEURON_DEVICE_MEMORY_IN_MIB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.ec2#NeuronInfo$TotalNeuronDeviceMemoryInMiB",
   36     36   
        "com.amazonaws.ec2",
   37     37   
        "NeuronInfo",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Integer,
   40         -
    "total_neuron_device_memory_in_mib",
          40  +
    "TotalNeuronDeviceMemoryInMiB",
   41     41   
    1,
   42     42   
)
   43     43   
.with_xml_name("totalNeuronDeviceMemoryInMiB");
   44     44   
static NEURONINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   45     45   
    NEURONINFO_SCHEMA_ID,
   46     46   
    ::aws_smithy_schema::ShapeType::Structure,
   47     47   
    &[&NEURONINFO_MEMBER_NEURON_DEVICES, &NEURONINFO_MEMBER_TOTAL_NEURON_DEVICE_MEMORY_IN_MIB],
   48     48   
);
   49     49   
impl NeuronInfo {
   50     50   
    /// The schema for this shape.
   51     51   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NEURONINFO_SCHEMA;
   52     52   
}
   53     53   
impl ::aws_smithy_schema::serde::SerializableStruct for NeuronInfo {
   54     54   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   55     55   
    fn serialize_members(
   56     56   
        &self,
   57     57   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   58     58   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   59     59   
        if let Some(ref val) = self.neuron_devices {
   60     60   
            ser.write_list(
   61     61   
                &NEURONINFO_MEMBER_NEURON_DEVICES,
   62     62   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   63     63   
                    for item in val {
   64     64   
                        ser.write_struct(crate::types::NeuronDeviceInfo::SCHEMA, item)?;
   65     65   
                    }
   66     66   
                    Ok(())
   67     67   
                },
   68     68   
            )?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.total_neuron_device_memory_in_mib {
   71     71   
            ser.write_integer(&NEURONINFO_MEMBER_TOTAL_NEURON_DEVICE_MEMORY_IN_MIB, *val)?;
   72     72   
        }
   73     73   
        Ok(())
   74     74   
    }
   75     75   
}
   76     76   
impl NeuronInfo {
   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(&NEURONINFO_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&NEURONINFO_SCHEMA, &mut |member, deser| {
   91     91   
            match member.member_index() {
   92     92   
                Some(0) => {
   93     93   
                    builder.neuron_devices = Some({
   94         -
                        let container = if let Some(cap) = deser.container_size() {
   95         -
                            Vec::with_capacity(cap)
   96         -
                        } else {
   97         -
                            Vec::new()
   98         -
                        };
   99         -
                        deser.read_list(member, container, |mut list, deser| {
  100         -
                            list.push(crate::types::NeuronDeviceInfo::deserialize(deser)?);
  101         -
                            Ok(list)
  102         -
                        })?
          94  +
                        let mut container = Vec::new();
          95  +
                        deser.read_list(member, &mut |deser| {
          96  +
                            container.push(crate::types::NeuronDeviceInfo::deserialize(deser)?);
          97  +
                            Ok(())
          98  +
                        })?;
          99  +
                        container
  103    100   
                    });
  104    101   
                }
  105    102   
                Some(1) => {
  106    103   
                    builder.total_neuron_device_memory_in_mib = Some(deser.read_integer(member)?);
  107    104   
                }
  108    105   
                _ => {}
  109    106   
            }
  110    107   
            Ok(())
  111    108   
        })?;
  112    109   
        Ok(builder.build())
  113    110   
    }
  114    111   
}
         112  +
impl NeuronInfo {
         113  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         114  +
    pub fn deserialize_with_response(
         115  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         116  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         117  +
        _status: u16,
         118  +
        _body: &[u8],
         119  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         120  +
        Self::deserialize(deserializer)
         121  +
    }
         122  +
}
  115    123   
impl NeuronInfo {
  116    124   
    /// Creates a new builder-style object to manufacture [`NeuronInfo`](crate::types::NeuronInfo).
  117    125   
    pub fn builder() -> crate::types::builders::NeuronInfoBuilder {
  118    126   
        crate::types::builders::NeuronInfoBuilder::default()
  119    127   
    }
  120    128   
}
  121    129   
  122    130   
/// A builder for [`NeuronInfo`](crate::types::NeuronInfo).
  123    131   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  124    132   
#[non_exhaustive]

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

@@ -1,1 +144,145 @@
   19     19   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.values.is_none()`.
   20     20   
    pub fn values(&self) -> &[::std::string::String] {
   21     21   
        self.values.as_deref().unwrap_or_default()
   22     22   
    }
   23     23   
}
   24     24   
static NEWDHCPCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NewDhcpConfiguration", "com.amazonaws.ec2", "NewDhcpConfiguration");
   26     26   
static NEWDHCPCONFIGURATION_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NewDhcpConfiguration$Key", "com.amazonaws.ec2", "NewDhcpConfiguration"),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "key",
          29  +
    "Key",
   30     30   
    0,
   31     31   
)
   32     32   
.with_xml_name("key");
   33     33   
static NEWDHCPCONFIGURATION_MEMBER_VALUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.ec2#NewDhcpConfiguration$Values",
   36     36   
        "com.amazonaws.ec2",
   37     37   
        "NewDhcpConfiguration",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::List,
   40         -
    "values",
          40  +
    "Values",
   41     41   
    1,
   42     42   
)
   43     43   
.with_xml_name("Value");
   44     44   
static NEWDHCPCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   45     45   
    NEWDHCPCONFIGURATION_SCHEMA_ID,
   46     46   
    ::aws_smithy_schema::ShapeType::Structure,
   47     47   
    &[&NEWDHCPCONFIGURATION_MEMBER_KEY, &NEWDHCPCONFIGURATION_MEMBER_VALUES],
   48     48   
);
   49     49   
impl NewDhcpConfiguration {
   50     50   
    /// The schema for this shape.
   51     51   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NEWDHCPCONFIGURATION_SCHEMA;
   52     52   
}
   53     53   
impl ::aws_smithy_schema::serde::SerializableStruct for NewDhcpConfiguration {
   54     54   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   55     55   
    fn serialize_members(
   56     56   
        &self,
   57     57   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   58     58   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   59     59   
        if let Some(ref val) = self.key {
   60     60   
            ser.write_string(&NEWDHCPCONFIGURATION_MEMBER_KEY, val)?;
   61     61   
        }
   62     62   
        if let Some(ref val) = self.values {
   63     63   
            ser.write_list(
   64     64   
                &NEWDHCPCONFIGURATION_MEMBER_VALUES,
   65     65   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   66     66   
                    for item in val {
   67     67   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
   68     68   
                    }
   69     69   
                    Ok(())
   70     70   
                },
   71     71   
            )?;
   72     72   
        }
   73     73   
        Ok(())
   74     74   
    }
   75     75   
}
   76     76   
impl NewDhcpConfiguration {
   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(&NEWDHCPCONFIGURATION_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&NEWDHCPCONFIGURATION_SCHEMA, &mut |member, deser| {
   91     91   
            match member.member_index() {
   92     92   
                Some(0) => {
   93     93   
                    builder.key = Some(deser.read_string(member)?);
   94     94   
                }
   95     95   
                Some(1) => {
   96         -
                    builder.values = Some({
   97         -
                        let container = if let Some(cap) = deser.container_size() {
   98         -
                            Vec::with_capacity(cap)
   99         -
                        } else {
  100         -
                            Vec::new()
  101         -
                        };
  102         -
                        deser.read_list(member, container, |mut list, deser| {
  103         -
                            list.push(deser.read_string(member)?);
  104         -
                            Ok(list)
  105         -
                        })?
  106         -
                    });
          96  +
                    builder.values = Some(deser.read_string_list(member)?);
  107     97   
                }
  108     98   
                _ => {}
  109     99   
            }
  110    100   
            Ok(())
  111    101   
        })?;
  112    102   
        Ok(builder.build())
  113    103   
    }
  114    104   
}
         105  +
impl NewDhcpConfiguration {
         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  +
}
  115    116   
impl NewDhcpConfiguration {
  116    117   
    /// Creates a new builder-style object to manufacture [`NewDhcpConfiguration`](crate::types::NewDhcpConfiguration).
  117    118   
    pub fn builder() -> crate::types::builders::NewDhcpConfigurationBuilder {
  118    119   
        crate::types::builders::NewDhcpConfigurationBuilder::default()
  119    120   
    }
  120    121   
}
  121    122   
  122    123   
/// A builder for [`NewDhcpConfiguration`](crate::types::NewDhcpConfiguration).
  123    124   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  124    125   
#[non_exhaustive]

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

@@ -1,1 +121,122 @@
   13     13   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.supported_versions.is_none()`.
   14     14   
    pub fn supported_versions(&self) -> &[::std::string::String] {
   15     15   
        self.supported_versions.as_deref().unwrap_or_default()
   16     16   
    }
   17     17   
}
   18     18   
static NITROTPMINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NitroTpmInfo", "com.amazonaws.ec2", "NitroTpmInfo");
   20     20   
static NITROTPMINFO_MEMBER_SUPPORTED_VERSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   21     21   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#NitroTpmInfo$SupportedVersions", "com.amazonaws.ec2", "NitroTpmInfo"),
   22     22   
    ::aws_smithy_schema::ShapeType::List,
   23         -
    "supported_versions",
          23  +
    "SupportedVersions",
   24     24   
    0,
   25     25   
)
   26     26   
.with_xml_name("supportedVersions");
   27     27   
static NITROTPMINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   28     28   
    NITROTPMINFO_SCHEMA_ID,
   29     29   
    ::aws_smithy_schema::ShapeType::Structure,
   30     30   
    &[&NITROTPMINFO_MEMBER_SUPPORTED_VERSIONS],
   31     31   
);
   32     32   
impl NitroTpmInfo {
   33     33   
    /// The schema for this shape.
   34     34   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NITROTPMINFO_SCHEMA;
   35     35   
}
   36     36   
impl ::aws_smithy_schema::serde::SerializableStruct for NitroTpmInfo {
   37     37   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   38     38   
    fn serialize_members(
   39     39   
        &self,
   40     40   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   41     41   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   42     42   
        if let Some(ref val) = self.supported_versions {
   43     43   
            ser.write_list(
   44     44   
                &NITROTPMINFO_MEMBER_SUPPORTED_VERSIONS,
   45     45   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   46     46   
                    for item in val {
   47     47   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
   48     48   
                    }
   49     49   
                    Ok(())
   50     50   
                },
   51     51   
            )?;
   52     52   
        }
   53     53   
        Ok(())
   54     54   
    }
   55     55   
}
   56     56   
impl NitroTpmInfo {
   57     57   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   58         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   59         -
        deserializer: &mut D,
          58  +
    pub fn deserialize(
          59  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   60     60   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   61     61   
        #[allow(unused_variables, unused_mut)]
   62     62   
        let mut builder = Self::builder();
   63     63   
        #[allow(
   64     64   
            unused_variables,
   65     65   
            unreachable_code,
   66     66   
            clippy::single_match,
   67     67   
            clippy::match_single_binding,
   68     68   
            clippy::diverging_sub_expression
   69     69   
        )]
   70         -
        deserializer.read_struct(&NITROTPMINFO_SCHEMA, (), |_, member, deser| {
          70  +
        deserializer.read_struct(&NITROTPMINFO_SCHEMA, &mut |member, deser| {
   71     71   
            match member.member_index() {
   72     72   
                Some(0) => {
   73         -
                    builder.supported_versions = Some({
   74         -
                        let container = if let Some(cap) = deser.container_size() {
   75         -
                            Vec::with_capacity(cap)
   76         -
                        } else {
   77         -
                            Vec::new()
   78         -
                        };
   79         -
                        deser.read_list(member, container, |mut list, deser| {
   80         -
                            list.push(deser.read_string(member)?);
   81         -
                            Ok(list)
   82         -
                        })?
   83         -
                    });
          73  +
                    builder.supported_versions = Some(deser.read_string_list(member)?);
   84     74   
                }
   85     75   
                _ => {}
   86     76   
            }
   87     77   
            Ok(())
   88     78   
        })?;
   89     79   
        Ok(builder.build())
   90     80   
    }
   91     81   
}
          82  +
impl NitroTpmInfo {
          83  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          84  +
    pub fn deserialize_with_response(
          85  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          86  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          87  +
        _status: u16,
          88  +
        _body: &[u8],
          89  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          90  +
        Self::deserialize(deserializer)
          91  +
    }
          92  +
}
   92     93   
impl NitroTpmInfo {
   93     94   
    /// Creates a new builder-style object to manufacture [`NitroTpmInfo`](crate::types::NitroTpmInfo).
   94     95   
    pub fn builder() -> crate::types::builders::NitroTpmInfoBuilder {
   95     96   
        crate::types::builders::NitroTpmInfoBuilder::default()
   96     97   
    }
   97     98   
}
   98     99   
   99    100   
/// A builder for [`NitroTpmInfo`](crate::types::NitroTpmInfo).
  100    101   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  101    102   
#[non_exhaustive]

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

@@ -40,40 +236,247 @@
   60     60   
        formatter.field("client_secret", &"*** Sensitive Data Redacted ***");
   61     61   
        formatter.field("scope", &self.scope);
   62     62   
        formatter.finish()
   63     63   
    }
   64     64   
}
   65     65   
static OIDCOPTIONS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   66     66   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OidcOptions", "com.amazonaws.ec2", "OidcOptions");
   67     67   
static OIDCOPTIONS_MEMBER_ISSUER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OidcOptions$Issuer", "com.amazonaws.ec2", "OidcOptions"),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "issuer",
          70  +
    "Issuer",
   71     71   
    0,
   72     72   
)
   73     73   
.with_xml_name("issuer");
   74     74   
static OIDCOPTIONS_MEMBER_AUTHORIZATION_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OidcOptions$AuthorizationEndpoint", "com.amazonaws.ec2", "OidcOptions"),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "authorization_endpoint",
          77  +
    "AuthorizationEndpoint",
   78     78   
    1,
   79     79   
)
   80     80   
.with_xml_name("authorizationEndpoint");
   81     81   
static OIDCOPTIONS_MEMBER_TOKEN_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OidcOptions$TokenEndpoint", "com.amazonaws.ec2", "OidcOptions"),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "token_endpoint",
          84  +
    "TokenEndpoint",
   85     85   
    2,
   86     86   
)
   87     87   
.with_xml_name("tokenEndpoint");
   88     88   
static OIDCOPTIONS_MEMBER_USER_INFO_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OidcOptions$UserInfoEndpoint", "com.amazonaws.ec2", "OidcOptions"),
   90     90   
    ::aws_smithy_schema::ShapeType::String,
   91         -
    "user_info_endpoint",
          91  +
    "UserInfoEndpoint",
   92     92   
    3,
   93     93   
)
   94     94   
.with_xml_name("userInfoEndpoint");
   95     95   
static OIDCOPTIONS_MEMBER_CLIENT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OidcOptions$ClientId", "com.amazonaws.ec2", "OidcOptions"),
   97     97   
    ::aws_smithy_schema::ShapeType::String,
   98         -
    "client_id",
          98  +
    "ClientId",
   99     99   
    4,
  100    100   
)
  101    101   
.with_xml_name("clientId");
  102    102   
static OIDCOPTIONS_MEMBER_CLIENT_SECRET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OidcOptions$ClientSecret", "com.amazonaws.ec2", "OidcOptions"),
  104    104   
    ::aws_smithy_schema::ShapeType::String,
  105         -
    "client_secret",
         105  +
    "ClientSecret",
  106    106   
    5,
  107    107   
)
  108    108   
.with_xml_name("clientSecret");
  109    109   
static OIDCOPTIONS_MEMBER_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OidcOptions$Scope", "com.amazonaws.ec2", "OidcOptions"),
  111    111   
    ::aws_smithy_schema::ShapeType::String,
  112         -
    "scope",
         112  +
    "Scope",
  113    113   
    6,
  114    114   
)
  115    115   
.with_xml_name("scope");
  116    116   
static OIDCOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  117    117   
    OIDCOPTIONS_SCHEMA_ID,
  118    118   
    ::aws_smithy_schema::ShapeType::Structure,
  119    119   
    &[
  120    120   
        &OIDCOPTIONS_MEMBER_ISSUER,
  121    121   
        &OIDCOPTIONS_MEMBER_AUTHORIZATION_ENDPOINT,
  122    122   
        &OIDCOPTIONS_MEMBER_TOKEN_ENDPOINT,
  123    123   
        &OIDCOPTIONS_MEMBER_USER_INFO_ENDPOINT,
  124    124   
        &OIDCOPTIONS_MEMBER_CLIENT_ID,
  125    125   
        &OIDCOPTIONS_MEMBER_CLIENT_SECRET,
  126    126   
        &OIDCOPTIONS_MEMBER_SCOPE,
  127    127   
    ],
  128    128   
);
  129    129   
impl OidcOptions {
  130    130   
    /// The schema for this shape.
  131    131   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OIDCOPTIONS_SCHEMA;
  132    132   
}
  133    133   
impl ::aws_smithy_schema::serde::SerializableStruct for OidcOptions {
  134    134   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  135    135   
    fn serialize_members(
  136    136   
        &self,
  137    137   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  138    138   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  139    139   
        if let Some(ref val) = self.issuer {
  140    140   
            ser.write_string(&OIDCOPTIONS_MEMBER_ISSUER, val)?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.authorization_endpoint {
  143    143   
            ser.write_string(&OIDCOPTIONS_MEMBER_AUTHORIZATION_ENDPOINT, val)?;
  144    144   
        }
  145    145   
        if let Some(ref val) = self.token_endpoint {
  146    146   
            ser.write_string(&OIDCOPTIONS_MEMBER_TOKEN_ENDPOINT, val)?;
  147    147   
        }
  148    148   
        if let Some(ref val) = self.user_info_endpoint {
  149    149   
            ser.write_string(&OIDCOPTIONS_MEMBER_USER_INFO_ENDPOINT, val)?;
  150    150   
        }
  151    151   
        if let Some(ref val) = self.client_id {
  152    152   
            ser.write_string(&OIDCOPTIONS_MEMBER_CLIENT_ID, val)?;
  153    153   
        }
  154    154   
        if let Some(ref val) = self.client_secret {
  155    155   
            ser.write_string(&OIDCOPTIONS_MEMBER_CLIENT_SECRET, val)?;
  156    156   
        }
  157    157   
        if let Some(ref val) = self.scope {
  158    158   
            ser.write_string(&OIDCOPTIONS_MEMBER_SCOPE, val)?;
  159    159   
        }
  160    160   
        Ok(())
  161    161   
    }
  162    162   
}
  163    163   
impl OidcOptions {
  164    164   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  165         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  166         -
        deserializer: &mut D,
         165  +
    pub fn deserialize(
         166  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  167    167   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  168    168   
        #[allow(unused_variables, unused_mut)]
  169    169   
        let mut builder = Self::builder();
  170    170   
        #[allow(
  171    171   
            unused_variables,
  172    172   
            unreachable_code,
  173    173   
            clippy::single_match,
  174    174   
            clippy::match_single_binding,
  175    175   
            clippy::diverging_sub_expression
  176    176   
        )]
  177         -
        deserializer.read_struct(&OIDCOPTIONS_SCHEMA, (), |_, member, deser| {
         177  +
        deserializer.read_struct(&OIDCOPTIONS_SCHEMA, &mut |member, deser| {
  178    178   
            match member.member_index() {
  179    179   
                Some(0) => {
  180    180   
                    builder.issuer = Some(deser.read_string(member)?);
  181    181   
                }
  182    182   
                Some(1) => {
  183    183   
                    builder.authorization_endpoint = Some(deser.read_string(member)?);
  184    184   
                }
  185    185   
                Some(2) => {
  186    186   
                    builder.token_endpoint = Some(deser.read_string(member)?);
  187    187   
                }
  188    188   
                Some(3) => {
  189    189   
                    builder.user_info_endpoint = Some(deser.read_string(member)?);
  190    190   
                }
  191    191   
                Some(4) => {
  192    192   
                    builder.client_id = Some(deser.read_string(member)?);
  193    193   
                }
  194    194   
                Some(5) => {
  195    195   
                    builder.client_secret = Some(deser.read_string(member)?);
  196    196   
                }
  197    197   
                Some(6) => {
  198    198   
                    builder.scope = Some(deser.read_string(member)?);
  199    199   
                }
  200    200   
                _ => {}
  201    201   
            }
  202    202   
            Ok(())
  203    203   
        })?;
  204    204   
        Ok(builder.build())
  205    205   
    }
  206    206   
}
         207  +
impl OidcOptions {
         208  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         209  +
    pub fn deserialize_with_response(
         210  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         211  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         212  +
        _status: u16,
         213  +
        _body: &[u8],
         214  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         215  +
        Self::deserialize(deserializer)
         216  +
    }
         217  +
}
  207    218   
impl OidcOptions {
  208    219   
    /// Creates a new builder-style object to manufacture [`OidcOptions`](crate::types::OidcOptions).
  209    220   
    pub fn builder() -> crate::types::builders::OidcOptionsBuilder {
  210    221   
        crate::types::builders::OidcOptionsBuilder::default()
  211    222   
    }
  212    223   
}
  213    224   
  214    225   
/// A builder for [`OidcOptions`](crate::types::OidcOptions).
  215    226   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  216    227   
#[non_exhaustive]

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

@@ -45,45 +243,254 @@
   65     65   
}
   66     66   
static ONDEMANDOPTIONS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OnDemandOptions", "com.amazonaws.ec2", "OnDemandOptions");
   68     68   
static ONDEMANDOPTIONS_MEMBER_ALLOCATION_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.ec2#OnDemandOptions$AllocationStrategy",
   71     71   
        "com.amazonaws.ec2",
   72     72   
        "OnDemandOptions",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "allocation_strategy",
          75  +
    "AllocationStrategy",
   76     76   
    0,
   77     77   
)
   78     78   
.with_xml_name("allocationStrategy");
   79     79   
static ONDEMANDOPTIONS_MEMBER_CAPACITY_RESERVATION_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.ec2#OnDemandOptions$CapacityReservationOptions",
   82     82   
        "com.amazonaws.ec2",
   83     83   
        "OnDemandOptions",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86         -
    "capacity_reservation_options",
          86  +
    "CapacityReservationOptions",
   87     87   
    1,
   88     88   
)
   89     89   
.with_xml_name("capacityReservationOptions");
   90     90   
static ONDEMANDOPTIONS_MEMBER_SINGLE_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.ec2#OnDemandOptions$SingleInstanceType",
   93     93   
        "com.amazonaws.ec2",
   94     94   
        "OnDemandOptions",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::Boolean,
   97         -
    "single_instance_type",
          97  +
    "SingleInstanceType",
   98     98   
    2,
   99     99   
)
  100    100   
.with_xml_name("singleInstanceType");
  101    101   
static ONDEMANDOPTIONS_MEMBER_SINGLE_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.ec2#OnDemandOptions$SingleAvailabilityZone",
  104    104   
        "com.amazonaws.ec2",
  105    105   
        "OnDemandOptions",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::Boolean,
  108         -
    "single_availability_zone",
         108  +
    "SingleAvailabilityZone",
  109    109   
    3,
  110    110   
)
  111    111   
.with_xml_name("singleAvailabilityZone");
  112    112   
static ONDEMANDOPTIONS_MEMBER_MIN_TARGET_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.ec2#OnDemandOptions$MinTargetCapacity",
  115    115   
        "com.amazonaws.ec2",
  116    116   
        "OnDemandOptions",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::Integer,
  119         -
    "min_target_capacity",
         119  +
    "MinTargetCapacity",
  120    120   
    4,
  121    121   
)
  122    122   
.with_xml_name("minTargetCapacity");
  123    123   
static ONDEMANDOPTIONS_MEMBER_MAX_TOTAL_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OnDemandOptions$MaxTotalPrice", "com.amazonaws.ec2", "OnDemandOptions"),
  125    125   
    ::aws_smithy_schema::ShapeType::String,
  126         -
    "max_total_price",
         126  +
    "MaxTotalPrice",
  127    127   
    5,
  128    128   
)
  129    129   
.with_xml_name("maxTotalPrice");
  130    130   
static ONDEMANDOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  131    131   
    ONDEMANDOPTIONS_SCHEMA_ID,
  132    132   
    ::aws_smithy_schema::ShapeType::Structure,
  133    133   
    &[
  134    134   
        &ONDEMANDOPTIONS_MEMBER_ALLOCATION_STRATEGY,
  135    135   
        &ONDEMANDOPTIONS_MEMBER_CAPACITY_RESERVATION_OPTIONS,
  136    136   
        &ONDEMANDOPTIONS_MEMBER_SINGLE_INSTANCE_TYPE,
  137    137   
        &ONDEMANDOPTIONS_MEMBER_SINGLE_AVAILABILITY_ZONE,
  138    138   
        &ONDEMANDOPTIONS_MEMBER_MIN_TARGET_CAPACITY,
  139    139   
        &ONDEMANDOPTIONS_MEMBER_MAX_TOTAL_PRICE,
  140    140   
    ],
  141    141   
);
  142    142   
impl OnDemandOptions {
  143    143   
    /// The schema for this shape.
  144    144   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ONDEMANDOPTIONS_SCHEMA;
  145    145   
}
  146    146   
impl ::aws_smithy_schema::serde::SerializableStruct for OnDemandOptions {
  147    147   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  148    148   
    fn serialize_members(
  149    149   
        &self,
  150    150   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  151    151   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  152    152   
        if let Some(ref val) = self.allocation_strategy {
  153    153   
            ser.write_string(&ONDEMANDOPTIONS_MEMBER_ALLOCATION_STRATEGY, val.as_str())?;
  154    154   
        }
  155    155   
        if let Some(ref val) = self.capacity_reservation_options {
  156    156   
            ser.write_struct(&ONDEMANDOPTIONS_MEMBER_CAPACITY_RESERVATION_OPTIONS, val)?;
  157    157   
        }
  158    158   
        if let Some(ref val) = self.single_instance_type {
  159    159   
            ser.write_boolean(&ONDEMANDOPTIONS_MEMBER_SINGLE_INSTANCE_TYPE, *val)?;
  160    160   
        }
  161    161   
        if let Some(ref val) = self.single_availability_zone {
  162    162   
            ser.write_boolean(&ONDEMANDOPTIONS_MEMBER_SINGLE_AVAILABILITY_ZONE, *val)?;
  163    163   
        }
  164    164   
        if let Some(ref val) = self.min_target_capacity {
  165    165   
            ser.write_integer(&ONDEMANDOPTIONS_MEMBER_MIN_TARGET_CAPACITY, *val)?;
  166    166   
        }
  167    167   
        if let Some(ref val) = self.max_total_price {
  168    168   
            ser.write_string(&ONDEMANDOPTIONS_MEMBER_MAX_TOTAL_PRICE, val)?;
  169    169   
        }
  170    170   
        Ok(())
  171    171   
    }
  172    172   
}
  173    173   
impl OnDemandOptions {
  174    174   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  175         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  176         -
        deserializer: &mut D,
         175  +
    pub fn deserialize(
         176  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  177    177   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  178    178   
        #[allow(unused_variables, unused_mut)]
  179    179   
        let mut builder = Self::builder();
  180    180   
        #[allow(
  181    181   
            unused_variables,
  182    182   
            unreachable_code,
  183    183   
            clippy::single_match,
  184    184   
            clippy::match_single_binding,
  185    185   
            clippy::diverging_sub_expression
  186    186   
        )]
  187         -
        deserializer.read_struct(&ONDEMANDOPTIONS_SCHEMA, (), |_, member, deser| {
         187  +
        deserializer.read_struct(&ONDEMANDOPTIONS_SCHEMA, &mut |member, deser| {
  188    188   
            match member.member_index() {
  189    189   
                Some(0) => {
  190    190   
                    builder.allocation_strategy = Some(crate::types::FleetOnDemandAllocationStrategy::from(deser.read_string(member)?.as_str()));
  191    191   
                }
  192    192   
                Some(1) => {
  193    193   
                    builder.capacity_reservation_options = Some(crate::types::CapacityReservationOptions::deserialize(deser)?);
  194    194   
                }
  195    195   
                Some(2) => {
  196    196   
                    builder.single_instance_type = Some(deser.read_boolean(member)?);
  197    197   
                }
  198    198   
                Some(3) => {
  199    199   
                    builder.single_availability_zone = Some(deser.read_boolean(member)?);
  200    200   
                }
  201    201   
                Some(4) => {
  202    202   
                    builder.min_target_capacity = Some(deser.read_integer(member)?);
  203    203   
                }
  204    204   
                Some(5) => {
  205    205   
                    builder.max_total_price = Some(deser.read_string(member)?);
  206    206   
                }
  207    207   
                _ => {}
  208    208   
            }
  209    209   
            Ok(())
  210    210   
        })?;
  211    211   
        Ok(builder.build())
  212    212   
    }
  213    213   
}
         214  +
impl OnDemandOptions {
         215  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         216  +
    pub fn deserialize_with_response(
         217  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         218  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         219  +
        _status: u16,
         220  +
        _body: &[u8],
         221  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         222  +
        Self::deserialize(deserializer)
         223  +
    }
         224  +
}
  214    225   
impl OnDemandOptions {
  215    226   
    /// Creates a new builder-style object to manufacture [`OnDemandOptions`](crate::types::OnDemandOptions).
  216    227   
    pub fn builder() -> crate::types::builders::OnDemandOptionsBuilder {
  217    228   
        crate::types::builders::OnDemandOptionsBuilder::default()
  218    229   
    }
  219    230   
}
  220    231   
  221    232   
/// A builder for [`OnDemandOptions`](crate::types::OnDemandOptions).
  222    233   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  223    234   
#[non_exhaustive]

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

@@ -45,45 +241,252 @@
   65     65   
}
   66     66   
static ONDEMANDOPTIONSREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OnDemandOptionsRequest", "com.amazonaws.ec2", "OnDemandOptionsRequest");
   68     68   
static ONDEMANDOPTIONSREQUEST_MEMBER_ALLOCATION_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.ec2#OnDemandOptionsRequest$AllocationStrategy",
   71     71   
        "com.amazonaws.ec2",
   72     72   
        "OnDemandOptionsRequest",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "allocation_strategy",
          75  +
    "AllocationStrategy",
   76     76   
    0,
   77     77   
);
   78     78   
static ONDEMANDOPTIONSREQUEST_MEMBER_CAPACITY_RESERVATION_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.ec2#OnDemandOptionsRequest$CapacityReservationOptions",
   81     81   
        "com.amazonaws.ec2",
   82     82   
        "OnDemandOptionsRequest",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::Structure,
   85         -
    "capacity_reservation_options",
          85  +
    "CapacityReservationOptions",
   86     86   
    1,
   87     87   
);
   88     88   
static ONDEMANDOPTIONSREQUEST_MEMBER_SINGLE_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.ec2#OnDemandOptionsRequest$SingleInstanceType",
   91     91   
        "com.amazonaws.ec2",
   92     92   
        "OnDemandOptionsRequest",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::Boolean,
   95         -
    "single_instance_type",
          95  +
    "SingleInstanceType",
   96     96   
    2,
   97     97   
);
   98     98   
static ONDEMANDOPTIONSREQUEST_MEMBER_SINGLE_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static(
  100    100   
        "com.amazonaws.ec2#OnDemandOptionsRequest$SingleAvailabilityZone",
  101    101   
        "com.amazonaws.ec2",
  102    102   
        "OnDemandOptionsRequest",
  103    103   
    ),
  104    104   
    ::aws_smithy_schema::ShapeType::Boolean,
  105         -
    "single_availability_zone",
         105  +
    "SingleAvailabilityZone",
  106    106   
    3,
  107    107   
);
  108    108   
static ONDEMANDOPTIONSREQUEST_MEMBER_MIN_TARGET_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static(
  110    110   
        "com.amazonaws.ec2#OnDemandOptionsRequest$MinTargetCapacity",
  111    111   
        "com.amazonaws.ec2",
  112    112   
        "OnDemandOptionsRequest",
  113    113   
    ),
  114    114   
    ::aws_smithy_schema::ShapeType::Integer,
  115         -
    "min_target_capacity",
         115  +
    "MinTargetCapacity",
  116    116   
    4,
  117    117   
);
  118    118   
static ONDEMANDOPTIONSREQUEST_MEMBER_MAX_TOTAL_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.ec2#OnDemandOptionsRequest$MaxTotalPrice",
  121    121   
        "com.amazonaws.ec2",
  122    122   
        "OnDemandOptionsRequest",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::String,
  125         -
    "max_total_price",
         125  +
    "MaxTotalPrice",
  126    126   
    5,
  127    127   
);
  128    128   
static ONDEMANDOPTIONSREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  129    129   
    ONDEMANDOPTIONSREQUEST_SCHEMA_ID,
  130    130   
    ::aws_smithy_schema::ShapeType::Structure,
  131    131   
    &[
  132    132   
        &ONDEMANDOPTIONSREQUEST_MEMBER_ALLOCATION_STRATEGY,
  133    133   
        &ONDEMANDOPTIONSREQUEST_MEMBER_CAPACITY_RESERVATION_OPTIONS,
  134    134   
        &ONDEMANDOPTIONSREQUEST_MEMBER_SINGLE_INSTANCE_TYPE,
  135    135   
        &ONDEMANDOPTIONSREQUEST_MEMBER_SINGLE_AVAILABILITY_ZONE,
  136    136   
        &ONDEMANDOPTIONSREQUEST_MEMBER_MIN_TARGET_CAPACITY,
  137    137   
        &ONDEMANDOPTIONSREQUEST_MEMBER_MAX_TOTAL_PRICE,
  138    138   
    ],
  139    139   
);
  140    140   
impl OnDemandOptionsRequest {
  141    141   
    /// The schema for this shape.
  142    142   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ONDEMANDOPTIONSREQUEST_SCHEMA;
  143    143   
}
  144    144   
impl ::aws_smithy_schema::serde::SerializableStruct for OnDemandOptionsRequest {
  145    145   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  146    146   
    fn serialize_members(
  147    147   
        &self,
  148    148   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  149    149   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  150    150   
        if let Some(ref val) = self.allocation_strategy {
  151    151   
            ser.write_string(&ONDEMANDOPTIONSREQUEST_MEMBER_ALLOCATION_STRATEGY, val.as_str())?;
  152    152   
        }
  153    153   
        if let Some(ref val) = self.capacity_reservation_options {
  154    154   
            ser.write_struct(&ONDEMANDOPTIONSREQUEST_MEMBER_CAPACITY_RESERVATION_OPTIONS, val)?;
  155    155   
        }
  156    156   
        if let Some(ref val) = self.single_instance_type {
  157    157   
            ser.write_boolean(&ONDEMANDOPTIONSREQUEST_MEMBER_SINGLE_INSTANCE_TYPE, *val)?;
  158    158   
        }
  159    159   
        if let Some(ref val) = self.single_availability_zone {
  160    160   
            ser.write_boolean(&ONDEMANDOPTIONSREQUEST_MEMBER_SINGLE_AVAILABILITY_ZONE, *val)?;
  161    161   
        }
  162    162   
        if let Some(ref val) = self.min_target_capacity {
  163    163   
            ser.write_integer(&ONDEMANDOPTIONSREQUEST_MEMBER_MIN_TARGET_CAPACITY, *val)?;
  164    164   
        }
  165    165   
        if let Some(ref val) = self.max_total_price {
  166    166   
            ser.write_string(&ONDEMANDOPTIONSREQUEST_MEMBER_MAX_TOTAL_PRICE, val)?;
  167    167   
        }
  168    168   
        Ok(())
  169    169   
    }
  170    170   
}
  171    171   
impl OnDemandOptionsRequest {
  172    172   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  173         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  174         -
        deserializer: &mut D,
         173  +
    pub fn deserialize(
         174  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  175    175   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  176    176   
        #[allow(unused_variables, unused_mut)]
  177    177   
        let mut builder = Self::builder();
  178    178   
        #[allow(
  179    179   
            unused_variables,
  180    180   
            unreachable_code,
  181    181   
            clippy::single_match,
  182    182   
            clippy::match_single_binding,
  183    183   
            clippy::diverging_sub_expression
  184    184   
        )]
  185         -
        deserializer.read_struct(&ONDEMANDOPTIONSREQUEST_SCHEMA, (), |_, member, deser| {
         185  +
        deserializer.read_struct(&ONDEMANDOPTIONSREQUEST_SCHEMA, &mut |member, deser| {
  186    186   
            match member.member_index() {
  187    187   
                Some(0) => {
  188    188   
                    builder.allocation_strategy = Some(crate::types::FleetOnDemandAllocationStrategy::from(deser.read_string(member)?.as_str()));
  189    189   
                }
  190    190   
                Some(1) => {
  191    191   
                    builder.capacity_reservation_options = Some(crate::types::CapacityReservationOptionsRequest::deserialize(deser)?);
  192    192   
                }
  193    193   
                Some(2) => {
  194    194   
                    builder.single_instance_type = Some(deser.read_boolean(member)?);
  195    195   
                }
  196    196   
                Some(3) => {
  197    197   
                    builder.single_availability_zone = Some(deser.read_boolean(member)?);
  198    198   
                }
  199    199   
                Some(4) => {
  200    200   
                    builder.min_target_capacity = Some(deser.read_integer(member)?);
  201    201   
                }
  202    202   
                Some(5) => {
  203    203   
                    builder.max_total_price = Some(deser.read_string(member)?);
  204    204   
                }
  205    205   
                _ => {}
  206    206   
            }
  207    207   
            Ok(())
  208    208   
        })?;
  209    209   
        Ok(builder.build())
  210    210   
    }
  211    211   
}
         212  +
impl OnDemandOptionsRequest {
         213  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         214  +
    pub fn deserialize_with_response(
         215  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         216  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         217  +
        _status: u16,
         218  +
        _body: &[u8],
         219  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         220  +
        Self::deserialize(deserializer)
         221  +
    }
         222  +
}
  212    223   
impl OnDemandOptionsRequest {
  213    224   
    /// Creates a new builder-style object to manufacture [`OnDemandOptionsRequest`](crate::types::OnDemandOptionsRequest).
  214    225   
    pub fn builder() -> crate::types::builders::OnDemandOptionsRequestBuilder {
  215    226   
        crate::types::builders::OnDemandOptionsRequestBuilder::default()
  216    227   
    }
  217    228   
}
  218    229   
  219    230   
/// A builder for [`OnDemandOptionsRequest`](crate::types::OnDemandOptionsRequest).
  220    231   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  221    232   
#[non_exhaustive]

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

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

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

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

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

@@ -33,33 +143,143 @@
   53     53   
    /// 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()`.
   54     54   
    pub fn tags(&self) -> &[crate::types::Tag] {
   55     55   
        self.tags.as_deref().unwrap_or_default()
   56     56   
    }
   57     57   
}
   58     58   
static OUTPOSTLAG_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   59     59   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OutpostLag", "com.amazonaws.ec2", "OutpostLag");
   60     60   
static OUTPOSTLAG_MEMBER_OUTPOST_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OutpostLag$OutpostArn", "com.amazonaws.ec2", "OutpostLag"),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "outpost_arn",
          63  +
    "OutpostArn",
   64     64   
    0,
   65     65   
)
   66     66   
.with_xml_name("outpostArn");
   67     67   
static OUTPOSTLAG_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OutpostLag$OwnerId", "com.amazonaws.ec2", "OutpostLag"),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "owner_id",
          70  +
    "OwnerId",
   71     71   
    1,
   72     72   
)
   73     73   
.with_xml_name("ownerId");
   74     74   
static OUTPOSTLAG_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OutpostLag$State", "com.amazonaws.ec2", "OutpostLag"),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "state",
          77  +
    "State",
   78     78   
    2,
   79     79   
)
   80     80   
.with_xml_name("state");
   81     81   
static OUTPOSTLAG_MEMBER_OUTPOST_LAG_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OutpostLag$OutpostLagId", "com.amazonaws.ec2", "OutpostLag"),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "outpost_lag_id",
          84  +
    "OutpostLagId",
   85     85   
    3,
   86     86   
)
   87     87   
.with_xml_name("outpostLagId");
   88     88   
static OUTPOSTLAG_MEMBER_LOCAL_GATEWAY_VIRTUAL_INTERFACE_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.ec2#OutpostLag$LocalGatewayVirtualInterfaceIds",
   91     91   
        "com.amazonaws.ec2",
   92     92   
        "OutpostLag",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::List,
   95         -
    "local_gateway_virtual_interface_ids",
          95  +
    "LocalGatewayVirtualInterfaceIds",
   96     96   
    4,
   97     97   
)
   98     98   
.with_xml_name("localGatewayVirtualInterfaceIdSet");
   99     99   
static OUTPOSTLAG_MEMBER_SERVICE_LINK_VIRTUAL_INTERFACE_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.ec2#OutpostLag$ServiceLinkVirtualInterfaceIds",
  102    102   
        "com.amazonaws.ec2",
  103    103   
        "OutpostLag",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::List,
  106         -
    "service_link_virtual_interface_ids",
         106  +
    "ServiceLinkVirtualInterfaceIds",
  107    107   
    5,
  108    108   
)
  109    109   
.with_xml_name("serviceLinkVirtualInterfaceIdSet");
  110    110   
static OUTPOSTLAG_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#OutpostLag$Tags", "com.amazonaws.ec2", "OutpostLag"),
  112    112   
    ::aws_smithy_schema::ShapeType::List,
  113         -
    "tags",
         113  +
    "Tags",
  114    114   
    6,
  115    115   
)
  116    116   
.with_xml_name("tagSet");
  117    117   
static OUTPOSTLAG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  118    118   
    OUTPOSTLAG_SCHEMA_ID,
  119    119   
    ::aws_smithy_schema::ShapeType::Structure,
  120    120   
    &[
  121    121   
        &OUTPOSTLAG_MEMBER_OUTPOST_ARN,
  122    122   
        &OUTPOSTLAG_MEMBER_OWNER_ID,
  123    123   
        &OUTPOSTLAG_MEMBER_STATE,
@@ -157,157 +288,276 @@
  177    177   
                    ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  178    178   
                }
  179    179   
                Ok(())
  180    180   
            })?;
  181    181   
        }
  182    182   
        Ok(())
  183    183   
    }
  184    184   
}
  185    185   
impl OutpostLag {
  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(&OUTPOSTLAG_SCHEMA, (), |_, member, deser| {
         199  +
        deserializer.read_struct(&OUTPOSTLAG_SCHEMA, &mut |member, deser| {
  200    200   
            match member.member_index() {
  201    201   
                Some(0) => {
  202    202   
                    builder.outpost_arn = Some(deser.read_string(member)?);
  203    203   
                }
  204    204   
                Some(1) => {
  205    205   
                    builder.owner_id = Some(deser.read_string(member)?);
  206    206   
                }
  207    207   
                Some(2) => {
  208    208   
                    builder.state = Some(deser.read_string(member)?);
  209    209   
                }
  210    210   
                Some(3) => {
  211    211   
                    builder.outpost_lag_id = Some(deser.read_string(member)?);
  212    212   
                }
  213    213   
                Some(4) => {
  214         -
                    builder.local_gateway_virtual_interface_ids = Some({
  215         -
                        let container = if let Some(cap) = deser.container_size() {
  216         -
                            Vec::with_capacity(cap)
  217         -
                        } else {
  218         -
                            Vec::new()
  219         -
                        };
  220         -
                        deser.read_list(member, container, |mut list, deser| {
  221         -
                            list.push(deser.read_string(member)?);
  222         -
                            Ok(list)
  223         -
                        })?
  224         -
                    });
         214  +
                    builder.local_gateway_virtual_interface_ids = Some(deser.read_string_list(member)?);
  225    215   
                }
  226    216   
                Some(5) => {
  227         -
                    builder.service_link_virtual_interface_ids = Some({
  228         -
                        let container = if let Some(cap) = deser.container_size() {
  229         -
                            Vec::with_capacity(cap)
  230         -
                        } else {
  231         -
                            Vec::new()
  232         -
                        };
  233         -
                        deser.read_list(member, container, |mut list, deser| {
  234         -
                            list.push(deser.read_string(member)?);
  235         -
                            Ok(list)
  236         -
                        })?
  237         -
                    });
         217  +
                    builder.service_link_virtual_interface_ids = Some(deser.read_string_list(member)?);
  238    218   
                }
  239    219   
                Some(6) => {
  240    220   
                    builder.tags = Some({
  241         -
                        let container = if let Some(cap) = deser.container_size() {
  242         -
                            Vec::with_capacity(cap)
  243         -
                        } else {
  244         -
                            Vec::new()
  245         -
                        };
  246         -
                        deser.read_list(member, container, |mut list, deser| {
  247         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  248         -
                            Ok(list)
  249         -
                        })?
         221  +
                        let mut container = Vec::new();
         222  +
                        deser.read_list(member, &mut |deser| {
         223  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         224  +
                            Ok(())
         225  +
                        })?;
         226  +
                        container
  250    227   
                    });
  251    228   
                }
  252    229   
                _ => {}
  253    230   
            }
  254    231   
            Ok(())
  255    232   
        })?;
  256    233   
        Ok(builder.build())
  257    234   
    }
  258    235   
}
         236  +
impl OutpostLag {
         237  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         238  +
    pub fn deserialize_with_response(
         239  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         240  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         241  +
        _status: u16,
         242  +
        _body: &[u8],
         243  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         244  +
        Self::deserialize(deserializer)
         245  +
    }
         246  +
}
  259    247   
impl OutpostLag {
  260    248   
    /// Creates a new builder-style object to manufacture [`OutpostLag`](crate::types::OutpostLag).
  261    249   
    pub fn builder() -> crate::types::builders::OutpostLagBuilder {
  262    250   
        crate::types::builders::OutpostLagBuilder::default()
  263    251   
    }
  264    252   
}
  265    253   
  266    254   
/// A builder for [`OutpostLag`](crate::types::OutpostLag).
  267    255   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  268    256   
#[non_exhaustive]

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

@@ -45,45 +171,171 @@
   65     65   
}
   66     66   
static PACKETHEADERSTATEMENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#PacketHeaderStatement", "com.amazonaws.ec2", "PacketHeaderStatement");
   68     68   
static PACKETHEADERSTATEMENT_MEMBER_SOURCE_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.ec2#PacketHeaderStatement$SourceAddresses",
   71     71   
        "com.amazonaws.ec2",
   72     72   
        "PacketHeaderStatement",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::List,
   75         -
    "source_addresses",
          75  +
    "SourceAddresses",
   76     76   
    0,
   77     77   
)
   78     78   
.with_xml_name("sourceAddressSet");
   79     79   
static PACKETHEADERSTATEMENT_MEMBER_DESTINATION_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.ec2#PacketHeaderStatement$DestinationAddresses",
   82     82   
        "com.amazonaws.ec2",
   83     83   
        "PacketHeaderStatement",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::List,
   86         -
    "destination_addresses",
          86  +
    "DestinationAddresses",
   87     87   
    1,
   88     88   
)
   89     89   
.with_xml_name("destinationAddressSet");
   90     90   
static PACKETHEADERSTATEMENT_MEMBER_SOURCE_PORTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.ec2#PacketHeaderStatement$SourcePorts",
   93     93   
        "com.amazonaws.ec2",
   94     94   
        "PacketHeaderStatement",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::List,
   97         -
    "source_ports",
          97  +
    "SourcePorts",
   98     98   
    2,
   99     99   
)
  100    100   
.with_xml_name("sourcePortSet");
  101    101   
static PACKETHEADERSTATEMENT_MEMBER_DESTINATION_PORTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.ec2#PacketHeaderStatement$DestinationPorts",
  104    104   
        "com.amazonaws.ec2",
  105    105   
        "PacketHeaderStatement",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::List,
  108         -
    "destination_ports",
         108  +
    "DestinationPorts",
  109    109   
    3,
  110    110   
)
  111    111   
.with_xml_name("destinationPortSet");
  112    112   
static PACKETHEADERSTATEMENT_MEMBER_SOURCE_PREFIX_LISTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.ec2#PacketHeaderStatement$SourcePrefixLists",
  115    115   
        "com.amazonaws.ec2",
  116    116   
        "PacketHeaderStatement",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::List,
  119         -
    "source_prefix_lists",
         119  +
    "SourcePrefixLists",
  120    120   
    4,
  121    121   
)
  122    122   
.with_xml_name("sourcePrefixListSet");
  123    123   
static PACKETHEADERSTATEMENT_MEMBER_DESTINATION_PREFIX_LISTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.ec2#PacketHeaderStatement$DestinationPrefixLists",
  126    126   
        "com.amazonaws.ec2",
  127    127   
        "PacketHeaderStatement",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::List,
  130         -
    "destination_prefix_lists",
         130  +
    "DestinationPrefixLists",
  131    131   
    5,
  132    132   
)
  133    133   
.with_xml_name("destinationPrefixListSet");
  134    134   
static PACKETHEADERSTATEMENT_MEMBER_PROTOCOLS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "com.amazonaws.ec2#PacketHeaderStatement$Protocols",
  137    137   
        "com.amazonaws.ec2",
  138    138   
        "PacketHeaderStatement",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::List,
  141         -
    "protocols",
         141  +
    "Protocols",
  142    142   
    6,
  143    143   
)
  144    144   
.with_xml_name("protocolSet");
  145    145   
static PACKETHEADERSTATEMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  146    146   
    PACKETHEADERSTATEMENT_SCHEMA_ID,
  147    147   
    ::aws_smithy_schema::ShapeType::Structure,
  148    148   
    &[
  149    149   
        &PACKETHEADERSTATEMENT_MEMBER_SOURCE_ADDRESSES,
  150    150   
        &PACKETHEADERSTATEMENT_MEMBER_DESTINATION_ADDRESSES,
  151    151   
        &PACKETHEADERSTATEMENT_MEMBER_SOURCE_PORTS,
@@ -220,220 +391,339 @@
  240    240   
                    }
  241    241   
                    Ok(())
  242    242   
                },
  243    243   
            )?;
  244    244   
        }
  245    245   
        Ok(())
  246    246   
    }
  247    247   
}
  248    248   
impl PacketHeaderStatement {
  249    249   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  250         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  251         -
        deserializer: &mut D,
         250  +
    pub fn deserialize(
         251  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  252    252   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  253    253   
        #[allow(unused_variables, unused_mut)]
  254    254   
        let mut builder = Self::builder();
  255    255   
        #[allow(
  256    256   
            unused_variables,
  257    257   
            unreachable_code,
  258    258   
            clippy::single_match,
  259    259   
            clippy::match_single_binding,
  260    260   
            clippy::diverging_sub_expression
  261    261   
        )]
  262         -
        deserializer.read_struct(&PACKETHEADERSTATEMENT_SCHEMA, (), |_, member, deser| {
         262  +
        deserializer.read_struct(&PACKETHEADERSTATEMENT_SCHEMA, &mut |member, deser| {
  263    263   
            match member.member_index() {
  264    264   
                Some(0) => {
  265         -
                    builder.source_addresses = Some({
  266         -
                        let container = if let Some(cap) = deser.container_size() {
  267         -
                            Vec::with_capacity(cap)
  268         -
                        } else {
  269         -
                            Vec::new()
  270         -
                        };
  271         -
                        deser.read_list(member, container, |mut list, deser| {
  272         -
                            list.push(deser.read_string(member)?);
  273         -
                            Ok(list)
  274         -
                        })?
  275         -
                    });
         265  +
                    builder.source_addresses = Some(deser.read_string_list(member)?);
  276    266   
                }
  277    267   
                Some(1) => {
  278         -
                    builder.destination_addresses = Some({
  279         -
                        let container = if let Some(cap) = deser.container_size() {
  280         -
                            Vec::with_capacity(cap)
  281         -
                        } else {
  282         -
                            Vec::new()
  283         -
                        };
  284         -
                        deser.read_list(member, container, |mut list, deser| {
  285         -
                            list.push(deser.read_string(member)?);
  286         -
                            Ok(list)
  287         -
                        })?
  288         -
                    });
         268  +
                    builder.destination_addresses = Some(deser.read_string_list(member)?);
  289    269   
                }
  290    270   
                Some(2) => {
  291         -
                    builder.source_ports = Some({
  292         -
                        let container = if let Some(cap) = deser.container_size() {
  293         -
                            Vec::with_capacity(cap)
  294         -
                        } else {
  295         -
                            Vec::new()
  296         -
                        };
  297         -
                        deser.read_list(member, container, |mut list, deser| {
  298         -
                            list.push(deser.read_string(member)?);
  299         -
                            Ok(list)
  300         -
                        })?
  301         -
                    });
         271  +
                    builder.source_ports = Some(deser.read_string_list(member)?);
  302    272   
                }
  303    273   
                Some(3) => {
  304         -
                    builder.destination_ports = Some({
  305         -
                        let container = if let Some(cap) = deser.container_size() {
  306         -
                            Vec::with_capacity(cap)
  307         -
                        } else {
  308         -
                            Vec::new()
  309         -
                        };
  310         -
                        deser.read_list(member, container, |mut list, deser| {
  311         -
                            list.push(deser.read_string(member)?);
  312         -
                            Ok(list)
  313         -
                        })?
  314         -
                    });
         274  +
                    builder.destination_ports = Some(deser.read_string_list(member)?);
  315    275   
                }
  316    276   
                Some(4) => {
  317         -
                    builder.source_prefix_lists = Some({
  318         -
                        let container = if let Some(cap) = deser.container_size() {
  319         -
                            Vec::with_capacity(cap)
  320         -
                        } else {
  321         -
                            Vec::new()
  322         -
                        };
  323         -
                        deser.read_list(member, container, |mut list, deser| {
  324         -
                            list.push(deser.read_string(member)?);
  325         -
                            Ok(list)
  326         -
                        })?
  327         -
                    });
         277  +
                    builder.source_prefix_lists = Some(deser.read_string_list(member)?);
  328    278   
                }
  329    279   
                Some(5) => {
  330         -
                    builder.destination_prefix_lists = Some({
  331         -
                        let container = if let Some(cap) = deser.container_size() {
  332         -
                            Vec::with_capacity(cap)
  333         -
                        } else {
  334         -
                            Vec::new()
  335         -
                        };
  336         -
                        deser.read_list(member, container, |mut list, deser| {
  337         -
                            list.push(deser.read_string(member)?);
  338         -
                            Ok(list)
  339         -
                        })?
  340         -
                    });
         280  +
                    builder.destination_prefix_lists = Some(deser.read_string_list(member)?);
  341    281   
                }
  342    282   
                Some(6) => {
  343    283   
                    builder.protocols = Some({
  344         -
                        let container = if let Some(cap) = deser.container_size() {
  345         -
                            Vec::with_capacity(cap)
  346         -
                        } else {
  347         -
                            Vec::new()
  348         -
                        };
  349         -
                        deser.read_list(member, container, |mut list, deser| {
  350         -
                            list.push(crate::types::Protocol::from(deser.read_string(member)?.as_str()));
  351         -
                            Ok(list)
  352         -
                        })?
         284  +
                        let mut container = Vec::new();
         285  +
                        deser.read_list(member, &mut |deser| {
         286  +
                            container.push(crate::types::Protocol::from(deser.read_string(member)?.as_str()));
         287  +
                            Ok(())
         288  +
                        })?;
         289  +
                        container
  353    290   
                    });
  354    291   
                }
  355    292   
                _ => {}
  356    293   
            }
  357    294   
            Ok(())
  358    295   
        })?;
  359    296   
        Ok(builder.build())
  360    297   
    }
  361    298   
}
         299  +
impl PacketHeaderStatement {
         300  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         301  +
    pub fn deserialize_with_response(
         302  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         303  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         304  +
        _status: u16,
         305  +
        _body: &[u8],
         306  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         307  +
        Self::deserialize(deserializer)
         308  +
    }
         309  +
}
  362    310   
impl PacketHeaderStatement {
  363    311   
    /// Creates a new builder-style object to manufacture [`PacketHeaderStatement`](crate::types::PacketHeaderStatement).
  364    312   
    pub fn builder() -> crate::types::builders::PacketHeaderStatementBuilder {
  365    313   
        crate::types::builders::PacketHeaderStatementBuilder::default()
  366    314   
    }
  367    315   
}
  368    316   
  369    317   
/// A builder for [`PacketHeaderStatement`](crate::types::PacketHeaderStatement).
  370    318   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  371    319   
#[non_exhaustive]

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

@@ -48,48 +174,174 @@
   68     68   
    "com.amazonaws.ec2",
   69     69   
    "PacketHeaderStatementRequest",
   70     70   
);
   71     71   
static PACKETHEADERSTATEMENTREQUEST_MEMBER_SOURCE_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.ec2#PacketHeaderStatementRequest$SourceAddresses",
   74     74   
        "com.amazonaws.ec2",
   75     75   
        "PacketHeaderStatementRequest",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::List,
   78         -
    "source_addresses",
          78  +
    "SourceAddresses",
   79     79   
    0,
   80     80   
)
   81     81   
.with_xml_name("SourceAddress");
   82     82   
static PACKETHEADERSTATEMENTREQUEST_MEMBER_DESTINATION_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.ec2#PacketHeaderStatementRequest$DestinationAddresses",
   85     85   
        "com.amazonaws.ec2",
   86     86   
        "PacketHeaderStatementRequest",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::List,
   89         -
    "destination_addresses",
          89  +
    "DestinationAddresses",
   90     90   
    1,
   91     91   
)
   92     92   
.with_xml_name("DestinationAddress");
   93     93   
static PACKETHEADERSTATEMENTREQUEST_MEMBER_SOURCE_PORTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.ec2#PacketHeaderStatementRequest$SourcePorts",
   96     96   
        "com.amazonaws.ec2",
   97     97   
        "PacketHeaderStatementRequest",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::List,
  100         -
    "source_ports",
         100  +
    "SourcePorts",
  101    101   
    2,
  102    102   
)
  103    103   
.with_xml_name("SourcePort");
  104    104   
static PACKETHEADERSTATEMENTREQUEST_MEMBER_DESTINATION_PORTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static(
  106    106   
        "com.amazonaws.ec2#PacketHeaderStatementRequest$DestinationPorts",
  107    107   
        "com.amazonaws.ec2",
  108    108   
        "PacketHeaderStatementRequest",
  109    109   
    ),
  110    110   
    ::aws_smithy_schema::ShapeType::List,
  111         -
    "destination_ports",
         111  +
    "DestinationPorts",
  112    112   
    3,
  113    113   
)
  114    114   
.with_xml_name("DestinationPort");
  115    115   
static PACKETHEADERSTATEMENTREQUEST_MEMBER_SOURCE_PREFIX_LISTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static(
  117    117   
        "com.amazonaws.ec2#PacketHeaderStatementRequest$SourcePrefixLists",
  118    118   
        "com.amazonaws.ec2",
  119    119   
        "PacketHeaderStatementRequest",
  120    120   
    ),
  121    121   
    ::aws_smithy_schema::ShapeType::List,
  122         -
    "source_prefix_lists",
         122  +
    "SourcePrefixLists",
  123    123   
    4,
  124    124   
)
  125    125   
.with_xml_name("SourcePrefixList");
  126    126   
static PACKETHEADERSTATEMENTREQUEST_MEMBER_DESTINATION_PREFIX_LISTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  127    127   
    ::aws_smithy_schema::ShapeId::from_static(
  128    128   
        "com.amazonaws.ec2#PacketHeaderStatementRequest$DestinationPrefixLists",
  129    129   
        "com.amazonaws.ec2",
  130    130   
        "PacketHeaderStatementRequest",
  131    131   
    ),
  132    132   
    ::aws_smithy_schema::ShapeType::List,
  133         -
    "destination_prefix_lists",
         133  +
    "DestinationPrefixLists",
  134    134   
    5,
  135    135   
)
  136    136   
.with_xml_name("DestinationPrefixList");
  137    137   
static PACKETHEADERSTATEMENTREQUEST_MEMBER_PROTOCOLS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static(
  139    139   
        "com.amazonaws.ec2#PacketHeaderStatementRequest$Protocols",
  140    140   
        "com.amazonaws.ec2",
  141    141   
        "PacketHeaderStatementRequest",
  142    142   
    ),
  143    143   
    ::aws_smithy_schema::ShapeType::List,
  144         -
    "protocols",
         144  +
    "Protocols",
  145    145   
    6,
  146    146   
)
  147    147   
.with_xml_name("Protocol");
  148    148   
static PACKETHEADERSTATEMENTREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  149    149   
    PACKETHEADERSTATEMENTREQUEST_SCHEMA_ID,
  150    150   
    ::aws_smithy_schema::ShapeType::Structure,
  151    151   
    &[
  152    152   
        &PACKETHEADERSTATEMENTREQUEST_MEMBER_SOURCE_ADDRESSES,
  153    153   
        &PACKETHEADERSTATEMENTREQUEST_MEMBER_DESTINATION_ADDRESSES,
  154    154   
        &PACKETHEADERSTATEMENTREQUEST_MEMBER_SOURCE_PORTS,
@@ -223,223 +394,342 @@
  243    243   
                    }
  244    244   
                    Ok(())
  245    245   
                },
  246    246   
            )?;
  247    247   
        }
  248    248   
        Ok(())
  249    249   
    }
  250    250   
}
  251    251   
impl PacketHeaderStatementRequest {
  252    252   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  253         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  254         -
        deserializer: &mut D,
         253  +
    pub fn deserialize(
         254  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  255    255   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  256    256   
        #[allow(unused_variables, unused_mut)]
  257    257   
        let mut builder = Self::builder();
  258    258   
        #[allow(
  259    259   
            unused_variables,
  260    260   
            unreachable_code,
  261    261   
            clippy::single_match,
  262    262   
            clippy::match_single_binding,
  263    263   
            clippy::diverging_sub_expression
  264    264   
        )]
  265         -
        deserializer.read_struct(&PACKETHEADERSTATEMENTREQUEST_SCHEMA, (), |_, member, deser| {
         265  +
        deserializer.read_struct(&PACKETHEADERSTATEMENTREQUEST_SCHEMA, &mut |member, deser| {
  266    266   
            match member.member_index() {
  267    267   
                Some(0) => {
  268         -
                    builder.source_addresses = Some({
  269         -
                        let container = if let Some(cap) = deser.container_size() {
  270         -
                            Vec::with_capacity(cap)
  271         -
                        } else {
  272         -
                            Vec::new()
  273         -
                        };
  274         -
                        deser.read_list(member, container, |mut list, deser| {
  275         -
                            list.push(deser.read_string(member)?);
  276         -
                            Ok(list)
  277         -
                        })?
  278         -
                    });
         268  +
                    builder.source_addresses = Some(deser.read_string_list(member)?);
  279    269   
                }
  280    270   
                Some(1) => {
  281         -
                    builder.destination_addresses = Some({
  282         -
                        let container = if let Some(cap) = deser.container_size() {
  283         -
                            Vec::with_capacity(cap)
  284         -
                        } else {
  285         -
                            Vec::new()
  286         -
                        };
  287         -
                        deser.read_list(member, container, |mut list, deser| {
  288         -
                            list.push(deser.read_string(member)?);
  289         -
                            Ok(list)
  290         -
                        })?
  291         -
                    });
         271  +
                    builder.destination_addresses = Some(deser.read_string_list(member)?);
  292    272   
                }
  293    273   
                Some(2) => {
  294         -
                    builder.source_ports = Some({
  295         -
                        let container = if let Some(cap) = deser.container_size() {
  296         -
                            Vec::with_capacity(cap)
  297         -
                        } else {
  298         -
                            Vec::new()
  299         -
                        };
  300         -
                        deser.read_list(member, container, |mut list, deser| {
  301         -
                            list.push(deser.read_string(member)?);
  302         -
                            Ok(list)
  303         -
                        })?
  304         -
                    });
         274  +
                    builder.source_ports = Some(deser.read_string_list(member)?);
  305    275   
                }
  306    276   
                Some(3) => {
  307         -
                    builder.destination_ports = Some({
  308         -
                        let container = if let Some(cap) = deser.container_size() {
  309         -
                            Vec::with_capacity(cap)
  310         -
                        } else {
  311         -
                            Vec::new()
  312         -
                        };
  313         -
                        deser.read_list(member, container, |mut list, deser| {
  314         -
                            list.push(deser.read_string(member)?);
  315         -
                            Ok(list)
  316         -
                        })?
  317         -
                    });
         277  +
                    builder.destination_ports = Some(deser.read_string_list(member)?);
  318    278   
                }
  319    279   
                Some(4) => {
  320         -
                    builder.source_prefix_lists = Some({
  321         -
                        let container = if let Some(cap) = deser.container_size() {
  322         -
                            Vec::with_capacity(cap)
  323         -
                        } else {
  324         -
                            Vec::new()
  325         -
                        };
  326         -
                        deser.read_list(member, container, |mut list, deser| {
  327         -
                            list.push(deser.read_string(member)?);
  328         -
                            Ok(list)
  329         -
                        })?
  330         -
                    });
         280  +
                    builder.source_prefix_lists = Some(deser.read_string_list(member)?);
  331    281   
                }
  332    282   
                Some(5) => {
  333         -
                    builder.destination_prefix_lists = Some({
  334         -
                        let container = if let Some(cap) = deser.container_size() {
  335         -
                            Vec::with_capacity(cap)
  336         -
                        } else {
  337         -
                            Vec::new()
  338         -
                        };
  339         -
                        deser.read_list(member, container, |mut list, deser| {
  340         -
                            list.push(deser.read_string(member)?);
  341         -
                            Ok(list)
  342         -
                        })?
  343         -
                    });
         283  +
                    builder.destination_prefix_lists = Some(deser.read_string_list(member)?);
  344    284   
                }
  345    285   
                Some(6) => {
  346    286   
                    builder.protocols = Some({
  347         -
                        let container = if let Some(cap) = deser.container_size() {
  348         -
                            Vec::with_capacity(cap)
  349         -
                        } else {
  350         -
                            Vec::new()
  351         -
                        };
  352         -
                        deser.read_list(member, container, |mut list, deser| {
  353         -
                            list.push(crate::types::Protocol::from(deser.read_string(member)?.as_str()));
  354         -
                            Ok(list)
  355         -
                        })?
         287  +
                        let mut container = Vec::new();
         288  +
                        deser.read_list(member, &mut |deser| {
         289  +
                            container.push(crate::types::Protocol::from(deser.read_string(member)?.as_str()));
         290  +
                            Ok(())
         291  +
                        })?;
         292  +
                        container
  356    293   
                    });
  357    294   
                }
  358    295   
                _ => {}
  359    296   
            }
  360    297   
            Ok(())
  361    298   
        })?;
  362    299   
        Ok(builder.build())
  363    300   
    }
  364    301   
}
         302  +
impl PacketHeaderStatementRequest {
         303  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         304  +
    pub fn deserialize_with_response(
         305  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         306  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         307  +
        _status: u16,
         308  +
        _body: &[u8],
         309  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         310  +
        Self::deserialize(deserializer)
         311  +
    }
         312  +
}
  365    313   
impl PacketHeaderStatementRequest {
  366    314   
    /// Creates a new builder-style object to manufacture [`PacketHeaderStatementRequest`](crate::types::PacketHeaderStatementRequest).
  367    315   
    pub fn builder() -> crate::types::builders::PacketHeaderStatementRequestBuilder {
  368    316   
        crate::types::builders::PacketHeaderStatementRequestBuilder::default()
  369    317   
    }
  370    318   
}
  371    319   
  372    320   
/// A builder for [`PacketHeaderStatementRequest`](crate::types::PacketHeaderStatementRequest).
  373    321   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  374    322   
#[non_exhaustive]