AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c (ignoring whitespace)

Files changed:

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

@@ -29,29 +225,236 @@
   49     49   
}
   50     50   
static SCHEDULEDINSTANCESEBS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   51     51   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ScheduledInstancesEbs", "com.amazonaws.ec2", "ScheduledInstancesEbs");
   52     52   
static SCHEDULEDINSTANCESEBS_MEMBER_DELETE_ON_TERMINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.ec2#ScheduledInstancesEbs$DeleteOnTermination",
   55     55   
        "com.amazonaws.ec2",
   56     56   
        "ScheduledInstancesEbs",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::Boolean,
   59         -
    "delete_on_termination",
          59  +
    "DeleteOnTermination",
   60     60   
    0,
   61     61   
);
   62     62   
static SCHEDULEDINSTANCESEBS_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.ec2#ScheduledInstancesEbs$Encrypted",
   65     65   
        "com.amazonaws.ec2",
   66     66   
        "ScheduledInstancesEbs",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::Boolean,
   69         -
    "encrypted",
          69  +
    "Encrypted",
   70     70   
    1,
   71     71   
);
   72     72   
static SCHEDULEDINSTANCESEBS_MEMBER_IOPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.ec2#ScheduledInstancesEbs$Iops",
   75     75   
        "com.amazonaws.ec2",
   76     76   
        "ScheduledInstancesEbs",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::Integer,
   79         -
    "iops",
          79  +
    "Iops",
   80     80   
    2,
   81     81   
);
   82     82   
static SCHEDULEDINSTANCESEBS_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.ec2#ScheduledInstancesEbs$SnapshotId",
   85     85   
        "com.amazonaws.ec2",
   86     86   
        "ScheduledInstancesEbs",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "snapshot_id",
          89  +
    "SnapshotId",
   90     90   
    3,
   91     91   
);
   92     92   
static SCHEDULEDINSTANCESEBS_MEMBER_VOLUME_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "com.amazonaws.ec2#ScheduledInstancesEbs$VolumeSize",
   95     95   
        "com.amazonaws.ec2",
   96     96   
        "ScheduledInstancesEbs",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::Integer,
   99         -
    "volume_size",
          99  +
    "VolumeSize",
  100    100   
    4,
  101    101   
);
  102    102   
static SCHEDULEDINSTANCESEBS_MEMBER_VOLUME_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static(
  104    104   
        "com.amazonaws.ec2#ScheduledInstancesEbs$VolumeType",
  105    105   
        "com.amazonaws.ec2",
  106    106   
        "ScheduledInstancesEbs",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "volume_type",
         109  +
    "VolumeType",
  110    110   
    5,
  111    111   
);
  112    112   
static SCHEDULEDINSTANCESEBS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  113    113   
    SCHEDULEDINSTANCESEBS_SCHEMA_ID,
  114    114   
    ::aws_smithy_schema::ShapeType::Structure,
  115    115   
    &[
  116    116   
        &SCHEDULEDINSTANCESEBS_MEMBER_DELETE_ON_TERMINATION,
  117    117   
        &SCHEDULEDINSTANCESEBS_MEMBER_ENCRYPTED,
  118    118   
        &SCHEDULEDINSTANCESEBS_MEMBER_IOPS,
  119    119   
        &SCHEDULEDINSTANCESEBS_MEMBER_SNAPSHOT_ID,
  120    120   
        &SCHEDULEDINSTANCESEBS_MEMBER_VOLUME_SIZE,
  121    121   
        &SCHEDULEDINSTANCESEBS_MEMBER_VOLUME_TYPE,
  122    122   
    ],
  123    123   
);
  124    124   
impl ScheduledInstancesEbs {
  125    125   
    /// The schema for this shape.
  126    126   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SCHEDULEDINSTANCESEBS_SCHEMA;
  127    127   
}
  128    128   
impl ::aws_smithy_schema::serde::SerializableStruct for ScheduledInstancesEbs {
  129    129   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  130    130   
    fn serialize_members(
  131    131   
        &self,
  132    132   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  133    133   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  134    134   
        if let Some(ref val) = self.delete_on_termination {
  135    135   
            ser.write_boolean(&SCHEDULEDINSTANCESEBS_MEMBER_DELETE_ON_TERMINATION, *val)?;
  136    136   
        }
  137    137   
        if let Some(ref val) = self.encrypted {
  138    138   
            ser.write_boolean(&SCHEDULEDINSTANCESEBS_MEMBER_ENCRYPTED, *val)?;
  139    139   
        }
  140    140   
        if let Some(ref val) = self.iops {
  141    141   
            ser.write_integer(&SCHEDULEDINSTANCESEBS_MEMBER_IOPS, *val)?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.snapshot_id {
  144    144   
            ser.write_string(&SCHEDULEDINSTANCESEBS_MEMBER_SNAPSHOT_ID, val)?;
  145    145   
        }
  146    146   
        if let Some(ref val) = self.volume_size {
  147    147   
            ser.write_integer(&SCHEDULEDINSTANCESEBS_MEMBER_VOLUME_SIZE, *val)?;
  148    148   
        }
  149    149   
        if let Some(ref val) = self.volume_type {
  150    150   
            ser.write_string(&SCHEDULEDINSTANCESEBS_MEMBER_VOLUME_TYPE, val)?;
  151    151   
        }
  152    152   
        Ok(())
  153    153   
    }
  154    154   
}
  155    155   
impl ScheduledInstancesEbs {
  156    156   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  157         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  158         -
        deserializer: &mut D,
         157  +
    pub fn deserialize(
         158  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  159    159   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  160    160   
        #[allow(unused_variables, unused_mut)]
  161    161   
        let mut builder = Self::builder();
  162    162   
        #[allow(
  163    163   
            unused_variables,
  164    164   
            unreachable_code,
  165    165   
            clippy::single_match,
  166    166   
            clippy::match_single_binding,
  167    167   
            clippy::diverging_sub_expression
  168    168   
        )]
  169         -
        deserializer.read_struct(&SCHEDULEDINSTANCESEBS_SCHEMA, (), |_, member, deser| {
         169  +
        deserializer.read_struct(&SCHEDULEDINSTANCESEBS_SCHEMA, &mut |member, deser| {
  170    170   
            match member.member_index() {
  171    171   
                Some(0) => {
  172    172   
                    builder.delete_on_termination = Some(deser.read_boolean(member)?);
  173    173   
                }
  174    174   
                Some(1) => {
  175    175   
                    builder.encrypted = Some(deser.read_boolean(member)?);
  176    176   
                }
  177    177   
                Some(2) => {
  178    178   
                    builder.iops = Some(deser.read_integer(member)?);
  179    179   
                }
  180    180   
                Some(3) => {
  181    181   
                    builder.snapshot_id = Some(deser.read_string(member)?);
  182    182   
                }
  183    183   
                Some(4) => {
  184    184   
                    builder.volume_size = Some(deser.read_integer(member)?);
  185    185   
                }
  186    186   
                Some(5) => {
  187    187   
                    builder.volume_type = Some(deser.read_string(member)?);
  188    188   
                }
  189    189   
                _ => {}
  190    190   
            }
  191    191   
            Ok(())
  192    192   
        })?;
  193    193   
        Ok(builder.build())
  194    194   
    }
  195    195   
}
         196  +
impl ScheduledInstancesEbs {
         197  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         198  +
    pub fn deserialize_with_response(
         199  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         200  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         201  +
        _status: u16,
         202  +
        _body: &[u8],
         203  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         204  +
        Self::deserialize(deserializer)
         205  +
    }
         206  +
}
  196    207   
impl ScheduledInstancesEbs {
  197    208   
    /// Creates a new builder-style object to manufacture [`ScheduledInstancesEbs`](crate::types::ScheduledInstancesEbs).
  198    209   
    pub fn builder() -> crate::types::builders::ScheduledInstancesEbsBuilder {
  199    210   
        crate::types::builders::ScheduledInstancesEbsBuilder::default()
  200    211   
    }
  201    212   
}
  202    213   
  203    214   
/// A builder for [`ScheduledInstancesEbs`](crate::types::ScheduledInstancesEbs).
  204    215   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  205    216   
#[non_exhaustive]

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

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

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

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

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

@@ -105,105 +298,298 @@
  125    125   
    "com.amazonaws.ec2",
  126    126   
    "ScheduledInstancesLaunchSpecification",
  127    127   
);
  128    128   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_BLOCK_DEVICE_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static(
  130    130   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$BlockDeviceMappings",
  131    131   
        "com.amazonaws.ec2",
  132    132   
        "ScheduledInstancesLaunchSpecification",
  133    133   
    ),
  134    134   
    ::aws_smithy_schema::ShapeType::List,
  135         -
    "block_device_mappings",
         135  +
    "BlockDeviceMappings",
  136    136   
    0,
  137    137   
)
  138    138   
.with_xml_name("BlockDeviceMapping");
  139    139   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_EBS_OPTIMIZED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static(
  141    141   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$EbsOptimized",
  142    142   
        "com.amazonaws.ec2",
  143    143   
        "ScheduledInstancesLaunchSpecification",
  144    144   
    ),
  145    145   
    ::aws_smithy_schema::ShapeType::Boolean,
  146         -
    "ebs_optimized",
         146  +
    "EbsOptimized",
  147    147   
    1,
  148    148   
);
  149    149   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_IAM_INSTANCE_PROFILE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static(
  151    151   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$IamInstanceProfile",
  152    152   
        "com.amazonaws.ec2",
  153    153   
        "ScheduledInstancesLaunchSpecification",
  154    154   
    ),
  155    155   
    ::aws_smithy_schema::ShapeType::Structure,
  156         -
    "iam_instance_profile",
         156  +
    "IamInstanceProfile",
  157    157   
    2,
  158    158   
);
  159    159   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  160    160   
    ::aws_smithy_schema::ShapeId::from_static(
  161    161   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$ImageId",
  162    162   
        "com.amazonaws.ec2",
  163    163   
        "ScheduledInstancesLaunchSpecification",
  164    164   
    ),
  165    165   
    ::aws_smithy_schema::ShapeType::String,
  166         -
    "image_id",
         166  +
    "ImageId",
  167    167   
    3,
  168    168   
);
  169    169   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  170    170   
    ::aws_smithy_schema::ShapeId::from_static(
  171    171   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$InstanceType",
  172    172   
        "com.amazonaws.ec2",
  173    173   
        "ScheduledInstancesLaunchSpecification",
  174    174   
    ),
  175    175   
    ::aws_smithy_schema::ShapeType::String,
  176         -
    "instance_type",
         176  +
    "InstanceType",
  177    177   
    4,
  178    178   
);
  179    179   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_KERNEL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  180    180   
    ::aws_smithy_schema::ShapeId::from_static(
  181    181   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$KernelId",
  182    182   
        "com.amazonaws.ec2",
  183    183   
        "ScheduledInstancesLaunchSpecification",
  184    184   
    ),
  185    185   
    ::aws_smithy_schema::ShapeType::String,
  186         -
    "kernel_id",
         186  +
    "KernelId",
  187    187   
    5,
  188    188   
);
  189    189   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_KEY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  190    190   
    ::aws_smithy_schema::ShapeId::from_static(
  191    191   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$KeyName",
  192    192   
        "com.amazonaws.ec2",
  193    193   
        "ScheduledInstancesLaunchSpecification",
  194    194   
    ),
  195    195   
    ::aws_smithy_schema::ShapeType::String,
  196         -
    "key_name",
         196  +
    "KeyName",
  197    197   
    6,
  198    198   
);
  199    199   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_MONITORING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  200    200   
    ::aws_smithy_schema::ShapeId::from_static(
  201    201   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$Monitoring",
  202    202   
        "com.amazonaws.ec2",
  203    203   
        "ScheduledInstancesLaunchSpecification",
  204    204   
    ),
  205    205   
    ::aws_smithy_schema::ShapeType::Structure,
  206         -
    "monitoring",
         206  +
    "Monitoring",
  207    207   
    7,
  208    208   
);
  209    209   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_NETWORK_INTERFACES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  210    210   
    ::aws_smithy_schema::ShapeId::from_static(
  211    211   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$NetworkInterfaces",
  212    212   
        "com.amazonaws.ec2",
  213    213   
        "ScheduledInstancesLaunchSpecification",
  214    214   
    ),
  215    215   
    ::aws_smithy_schema::ShapeType::List,
  216         -
    "network_interfaces",
         216  +
    "NetworkInterfaces",
  217    217   
    8,
  218    218   
)
  219    219   
.with_xml_name("NetworkInterface");
  220    220   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_PLACEMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  221    221   
    ::aws_smithy_schema::ShapeId::from_static(
  222    222   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$Placement",
  223    223   
        "com.amazonaws.ec2",
  224    224   
        "ScheduledInstancesLaunchSpecification",
  225    225   
    ),
  226    226   
    ::aws_smithy_schema::ShapeType::Structure,
  227         -
    "placement",
         227  +
    "Placement",
  228    228   
    9,
  229    229   
);
  230    230   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_RAMDISK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  231    231   
    ::aws_smithy_schema::ShapeId::from_static(
  232    232   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$RamdiskId",
  233    233   
        "com.amazonaws.ec2",
  234    234   
        "ScheduledInstancesLaunchSpecification",
  235    235   
    ),
  236    236   
    ::aws_smithy_schema::ShapeType::String,
  237         -
    "ramdisk_id",
         237  +
    "RamdiskId",
  238    238   
    10,
  239    239   
);
  240    240   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_SECURITY_GROUP_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  241    241   
    ::aws_smithy_schema::ShapeId::from_static(
  242    242   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$SecurityGroupIds",
  243    243   
        "com.amazonaws.ec2",
  244    244   
        "ScheduledInstancesLaunchSpecification",
  245    245   
    ),
  246    246   
    ::aws_smithy_schema::ShapeType::List,
  247         -
    "security_group_ids",
         247  +
    "SecurityGroupIds",
  248    248   
    11,
  249    249   
)
  250    250   
.with_xml_name("SecurityGroupId");
  251    251   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  252    252   
    ::aws_smithy_schema::ShapeId::from_static(
  253    253   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$SubnetId",
  254    254   
        "com.amazonaws.ec2",
  255    255   
        "ScheduledInstancesLaunchSpecification",
  256    256   
    ),
  257    257   
    ::aws_smithy_schema::ShapeType::String,
  258         -
    "subnet_id",
         258  +
    "SubnetId",
  259    259   
    12,
  260    260   
);
  261    261   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_USER_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  262    262   
    ::aws_smithy_schema::ShapeId::from_static(
  263    263   
        "com.amazonaws.ec2#ScheduledInstancesLaunchSpecification$UserData",
  264    264   
        "com.amazonaws.ec2",
  265    265   
        "ScheduledInstancesLaunchSpecification",
  266    266   
    ),
  267    267   
    ::aws_smithy_schema::ShapeType::String,
  268         -
    "user_data",
         268  +
    "UserData",
  269    269   
    13,
  270    270   
);
  271    271   
static SCHEDULEDINSTANCESLAUNCHSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  272    272   
    SCHEDULEDINSTANCESLAUNCHSPECIFICATION_SCHEMA_ID,
  273    273   
    ::aws_smithy_schema::ShapeType::Structure,
  274    274   
    &[
  275    275   
        &SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_BLOCK_DEVICE_MAPPINGS,
  276    276   
        &SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_EBS_OPTIMIZED,
  277    277   
        &SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_IAM_INSTANCE_PROFILE,
  278    278   
        &SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_IMAGE_ID,
@@ -343,343 +495,490 @@
  363    363   
            ser.write_string(&SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_SUBNET_ID, val)?;
  364    364   
        }
  365    365   
        if let Some(ref val) = self.user_data {
  366    366   
            ser.write_string(&SCHEDULEDINSTANCESLAUNCHSPECIFICATION_MEMBER_USER_DATA, val)?;
  367    367   
        }
  368    368   
        Ok(())
  369    369   
    }
  370    370   
}
  371    371   
impl ScheduledInstancesLaunchSpecification {
  372    372   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  373         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  374         -
        deserializer: &mut D,
         373  +
    pub fn deserialize(
         374  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  375    375   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  376    376   
        #[allow(unused_variables, unused_mut)]
  377    377   
        let mut builder = Self::builder();
  378    378   
        #[allow(
  379    379   
            unused_variables,
  380    380   
            unreachable_code,
  381    381   
            clippy::single_match,
  382    382   
            clippy::match_single_binding,
  383    383   
            clippy::diverging_sub_expression
  384    384   
        )]
  385         -
        deserializer.read_struct(&SCHEDULEDINSTANCESLAUNCHSPECIFICATION_SCHEMA, (), |_, member, deser| {
         385  +
        deserializer.read_struct(&SCHEDULEDINSTANCESLAUNCHSPECIFICATION_SCHEMA, &mut |member, deser| {
  386    386   
            match member.member_index() {
  387    387   
                Some(0) => {
  388    388   
                    builder.block_device_mappings = Some({
  389         -
                        let container = if let Some(cap) = deser.container_size() {
  390         -
                            Vec::with_capacity(cap)
  391         -
                        } else {
  392         -
                            Vec::new()
  393         -
                        };
  394         -
                        deser.read_list(member, container, |mut list, deser| {
  395         -
                            list.push(crate::types::ScheduledInstancesBlockDeviceMapping::deserialize(deser)?);
  396         -
                            Ok(list)
  397         -
                        })?
         389  +
                        let mut container = Vec::new();
         390  +
                        deser.read_list(member, &mut |deser| {
         391  +
                            container.push(crate::types::ScheduledInstancesBlockDeviceMapping::deserialize(deser)?);
         392  +
                            Ok(())
         393  +
                        })?;
         394  +
                        container
  398    395   
                    });
  399    396   
                }
  400    397   
                Some(1) => {
  401    398   
                    builder.ebs_optimized = Some(deser.read_boolean(member)?);
  402    399   
                }
  403    400   
                Some(2) => {
  404    401   
                    builder.iam_instance_profile = Some(crate::types::ScheduledInstancesIamInstanceProfile::deserialize(deser)?);
  405    402   
                }
  406    403   
                Some(3) => {
  407    404   
                    builder.image_id = Some(deser.read_string(member)?);
  408    405   
                }
  409    406   
                Some(4) => {
  410    407   
                    builder.instance_type = Some(deser.read_string(member)?);
  411    408   
                }
  412    409   
                Some(5) => {
  413    410   
                    builder.kernel_id = Some(deser.read_string(member)?);
  414    411   
                }
  415    412   
                Some(6) => {
  416    413   
                    builder.key_name = Some(deser.read_string(member)?);
  417    414   
                }
  418    415   
                Some(7) => {
  419    416   
                    builder.monitoring = Some(crate::types::ScheduledInstancesMonitoring::deserialize(deser)?);
  420    417   
                }
  421    418   
                Some(8) => {
  422    419   
                    builder.network_interfaces = Some({
  423         -
                        let container = if let Some(cap) = deser.container_size() {
  424         -
                            Vec::with_capacity(cap)
  425         -
                        } else {
  426         -
                            Vec::new()
  427         -
                        };
  428         -
                        deser.read_list(member, container, |mut list, deser| {
  429         -
                            list.push(crate::types::ScheduledInstancesNetworkInterface::deserialize(deser)?);
  430         -
                            Ok(list)
  431         -
                        })?
         420  +
                        let mut container = Vec::new();
         421  +
                        deser.read_list(member, &mut |deser| {
         422  +
                            container.push(crate::types::ScheduledInstancesNetworkInterface::deserialize(deser)?);
         423  +
                            Ok(())
         424  +
                        })?;
         425  +
                        container
  432    426   
                    });
  433    427   
                }
  434    428   
                Some(9) => {
  435    429   
                    builder.placement = Some(crate::types::ScheduledInstancesPlacement::deserialize(deser)?);
  436    430   
                }
  437    431   
                Some(10) => {
  438    432   
                    builder.ramdisk_id = Some(deser.read_string(member)?);
  439    433   
                }
  440    434   
                Some(11) => {
  441         -
                    builder.security_group_ids = Some({
  442         -
                        let container = if let Some(cap) = deser.container_size() {
  443         -
                            Vec::with_capacity(cap)
  444         -
                        } else {
  445         -
                            Vec::new()
  446         -
                        };
  447         -
                        deser.read_list(member, container, |mut list, deser| {
  448         -
                            list.push(deser.read_string(member)?);
  449         -
                            Ok(list)
  450         -
                        })?
  451         -
                    });
         435  +
                    builder.security_group_ids = Some(deser.read_string_list(member)?);
  452    436   
                }
  453    437   
                Some(12) => {
  454    438   
                    builder.subnet_id = Some(deser.read_string(member)?);
  455    439   
                }
  456    440   
                Some(13) => {
  457    441   
                    builder.user_data = Some(deser.read_string(member)?);
  458    442   
                }
  459    443   
                _ => {}
  460    444   
            }
  461    445   
            Ok(())
  462    446   
        })?;
  463    447   
        Ok(builder.build())
  464    448   
    }
  465    449   
}
         450  +
impl ScheduledInstancesLaunchSpecification {
         451  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         452  +
    pub fn deserialize_with_response(
         453  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         454  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         455  +
        _status: u16,
         456  +
        _body: &[u8],
         457  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         458  +
        Self::deserialize(deserializer)
         459  +
    }
         460  +
}
  466    461   
impl ScheduledInstancesLaunchSpecification {
  467    462   
    /// Creates a new builder-style object to manufacture [`ScheduledInstancesLaunchSpecification`](crate::types::ScheduledInstancesLaunchSpecification).
  468    463   
    pub fn builder() -> crate::types::builders::ScheduledInstancesLaunchSpecificationBuilder {
  469    464   
        crate::types::builders::ScheduledInstancesLaunchSpecificationBuilder::default()
  470    465   
    }
  471    466   
}
  472    467   
  473    468   
/// A builder for [`ScheduledInstancesLaunchSpecification`](crate::types::ScheduledInstancesLaunchSpecification).
  474    469   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  475    470   
#[non_exhaustive]

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

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

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

@@ -72,72 +246,246 @@
   92     92   
    "com.amazonaws.ec2",
   93     93   
    "ScheduledInstancesNetworkInterface",
   94     94   
);
   95     95   
static SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_ASSOCIATE_PUBLIC_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.ec2#ScheduledInstancesNetworkInterface$AssociatePublicIpAddress",
   98     98   
        "com.amazonaws.ec2",
   99     99   
        "ScheduledInstancesNetworkInterface",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::Boolean,
  102         -
    "associate_public_ip_address",
         102  +
    "AssociatePublicIpAddress",
  103    103   
    0,
  104    104   
);
  105    105   
static SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_DELETE_ON_TERMINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static(
  107    107   
        "com.amazonaws.ec2#ScheduledInstancesNetworkInterface$DeleteOnTermination",
  108    108   
        "com.amazonaws.ec2",
  109    109   
        "ScheduledInstancesNetworkInterface",
  110    110   
    ),
  111    111   
    ::aws_smithy_schema::ShapeType::Boolean,
  112         -
    "delete_on_termination",
         112  +
    "DeleteOnTermination",
  113    113   
    1,
  114    114   
);
  115    115   
static SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static(
  117    117   
        "com.amazonaws.ec2#ScheduledInstancesNetworkInterface$Description",
  118    118   
        "com.amazonaws.ec2",
  119    119   
        "ScheduledInstancesNetworkInterface",
  120    120   
    ),
  121    121   
    ::aws_smithy_schema::ShapeType::String,
  122         -
    "description",
         122  +
    "Description",
  123    123   
    2,
  124    124   
);
  125    125   
static SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_DEVICE_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "com.amazonaws.ec2#ScheduledInstancesNetworkInterface$DeviceIndex",
  128    128   
        "com.amazonaws.ec2",
  129    129   
        "ScheduledInstancesNetworkInterface",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::Integer,
  132         -
    "device_index",
         132  +
    "DeviceIndex",
  133    133   
    3,
  134    134   
);
  135    135   
static SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_GROUPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static(
  137    137   
        "com.amazonaws.ec2#ScheduledInstancesNetworkInterface$Groups",
  138    138   
        "com.amazonaws.ec2",
  139    139   
        "ScheduledInstancesNetworkInterface",
  140    140   
    ),
  141    141   
    ::aws_smithy_schema::ShapeType::List,
  142         -
    "groups",
         142  +
    "Groups",
  143    143   
    4,
  144    144   
)
  145    145   
.with_xml_name("Group");
  146    146   
static SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_IPV6_ADDRESS_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  147    147   
    ::aws_smithy_schema::ShapeId::from_static(
  148    148   
        "com.amazonaws.ec2#ScheduledInstancesNetworkInterface$Ipv6AddressCount",
  149    149   
        "com.amazonaws.ec2",
  150    150   
        "ScheduledInstancesNetworkInterface",
  151    151   
    ),
  152    152   
    ::aws_smithy_schema::ShapeType::Integer,
  153         -
    "ipv6_address_count",
         153  +
    "Ipv6AddressCount",
  154    154   
    5,
  155    155   
);
  156    156   
static SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_IPV6_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  157    157   
    ::aws_smithy_schema::ShapeId::from_static(
  158    158   
        "com.amazonaws.ec2#ScheduledInstancesNetworkInterface$Ipv6Addresses",
  159    159   
        "com.amazonaws.ec2",
  160    160   
        "ScheduledInstancesNetworkInterface",
  161    161   
    ),
  162    162   
    ::aws_smithy_schema::ShapeType::List,
  163         -
    "ipv6_addresses",
         163  +
    "Ipv6Addresses",
  164    164   
    6,
  165    165   
)
  166    166   
.with_xml_name("Ipv6Address");
  167    167   
static SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_NETWORK_INTERFACE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  168    168   
    ::aws_smithy_schema::ShapeId::from_static(
  169    169   
        "com.amazonaws.ec2#ScheduledInstancesNetworkInterface$NetworkInterfaceId",
  170    170   
        "com.amazonaws.ec2",
  171    171   
        "ScheduledInstancesNetworkInterface",
  172    172   
    ),
  173    173   
    ::aws_smithy_schema::ShapeType::String,
  174         -
    "network_interface_id",
         174  +
    "NetworkInterfaceId",
  175    175   
    7,
  176    176   
);
  177    177   
static SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_PRIVATE_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  178    178   
    ::aws_smithy_schema::ShapeId::from_static(
  179    179   
        "com.amazonaws.ec2#ScheduledInstancesNetworkInterface$PrivateIpAddress",
  180    180   
        "com.amazonaws.ec2",
  181    181   
        "ScheduledInstancesNetworkInterface",
  182    182   
    ),
  183    183   
    ::aws_smithy_schema::ShapeType::String,
  184         -
    "private_ip_address",
         184  +
    "PrivateIpAddress",
  185    185   
    8,
  186    186   
);
  187    187   
static SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_PRIVATE_IP_ADDRESS_CONFIGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  188    188   
    ::aws_smithy_schema::ShapeId::from_static(
  189    189   
        "com.amazonaws.ec2#ScheduledInstancesNetworkInterface$PrivateIpAddressConfigs",
  190    190   
        "com.amazonaws.ec2",
  191    191   
        "ScheduledInstancesNetworkInterface",
  192    192   
    ),
  193    193   
    ::aws_smithy_schema::ShapeType::List,
  194         -
    "private_ip_address_configs",
         194  +
    "PrivateIpAddressConfigs",
  195    195   
    9,
  196    196   
)
  197    197   
.with_xml_name("PrivateIpAddressConfig");
  198    198   
static SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_SECONDARY_PRIVATE_IP_ADDRESS_COUNT: ::aws_smithy_schema::Schema =
  199    199   
    ::aws_smithy_schema::Schema::new_member(
  200    200   
        ::aws_smithy_schema::ShapeId::from_static(
  201    201   
            "com.amazonaws.ec2#ScheduledInstancesNetworkInterface$SecondaryPrivateIpAddressCount",
  202    202   
            "com.amazonaws.ec2",
  203    203   
            "ScheduledInstancesNetworkInterface",
  204    204   
        ),
  205    205   
        ::aws_smithy_schema::ShapeType::Integer,
  206         -
        "secondary_private_ip_address_count",
         206  +
        "SecondaryPrivateIpAddressCount",
  207    207   
        10,
  208    208   
    );
  209    209   
static SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  210    210   
    ::aws_smithy_schema::ShapeId::from_static(
  211    211   
        "com.amazonaws.ec2#ScheduledInstancesNetworkInterface$SubnetId",
  212    212   
        "com.amazonaws.ec2",
  213    213   
        "ScheduledInstancesNetworkInterface",
  214    214   
    ),
  215    215   
    ::aws_smithy_schema::ShapeType::String,
  216         -
    "subnet_id",
         216  +
    "SubnetId",
  217    217   
    11,
  218    218   
);
  219    219   
static SCHEDULEDINSTANCESNETWORKINTERFACE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  220    220   
    SCHEDULEDINSTANCESNETWORKINTERFACE_SCHEMA_ID,
  221    221   
    ::aws_smithy_schema::ShapeType::Structure,
  222    222   
    &[
  223    223   
        &SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_ASSOCIATE_PUBLIC_IP_ADDRESS,
  224    224   
        &SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_DELETE_ON_TERMINATION,
  225    225   
        &SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_DESCRIPTION,
  226    226   
        &SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_DEVICE_INDEX,
@@ -282,282 +428,423 @@
  302    302   
            ser.write_integer(&SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_SECONDARY_PRIVATE_IP_ADDRESS_COUNT, *val)?;
  303    303   
        }
  304    304   
        if let Some(ref val) = self.subnet_id {
  305    305   
            ser.write_string(&SCHEDULEDINSTANCESNETWORKINTERFACE_MEMBER_SUBNET_ID, val)?;
  306    306   
        }
  307    307   
        Ok(())
  308    308   
    }
  309    309   
}
  310    310   
impl ScheduledInstancesNetworkInterface {
  311    311   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  312         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  313         -
        deserializer: &mut D,
         312  +
    pub fn deserialize(
         313  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  314    314   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  315    315   
        #[allow(unused_variables, unused_mut)]
  316    316   
        let mut builder = Self::builder();
  317    317   
        #[allow(
  318    318   
            unused_variables,
  319    319   
            unreachable_code,
  320    320   
            clippy::single_match,
  321    321   
            clippy::match_single_binding,
  322    322   
            clippy::diverging_sub_expression
  323    323   
        )]
  324         -
        deserializer.read_struct(&SCHEDULEDINSTANCESNETWORKINTERFACE_SCHEMA, (), |_, member, deser| {
         324  +
        deserializer.read_struct(&SCHEDULEDINSTANCESNETWORKINTERFACE_SCHEMA, &mut |member, deser| {
  325    325   
            match member.member_index() {
  326    326   
                Some(0) => {
  327    327   
                    builder.associate_public_ip_address = Some(deser.read_boolean(member)?);
  328    328   
                }
  329    329   
                Some(1) => {
  330    330   
                    builder.delete_on_termination = Some(deser.read_boolean(member)?);
  331    331   
                }
  332    332   
                Some(2) => {
  333    333   
                    builder.description = Some(deser.read_string(member)?);
  334    334   
                }
  335    335   
                Some(3) => {
  336    336   
                    builder.device_index = Some(deser.read_integer(member)?);
  337    337   
                }
  338    338   
                Some(4) => {
  339         -
                    builder.groups = Some({
  340         -
                        let container = if let Some(cap) = deser.container_size() {
  341         -
                            Vec::with_capacity(cap)
  342         -
                        } else {
  343         -
                            Vec::new()
  344         -
                        };
  345         -
                        deser.read_list(member, container, |mut list, deser| {
  346         -
                            list.push(deser.read_string(member)?);
  347         -
                            Ok(list)
  348         -
                        })?
  349         -
                    });
         339  +
                    builder.groups = Some(deser.read_string_list(member)?);
  350    340   
                }
  351    341   
                Some(5) => {
  352    342   
                    builder.ipv6_address_count = Some(deser.read_integer(member)?);
  353    343   
                }
  354    344   
                Some(6) => {
  355    345   
                    builder.ipv6_addresses = Some({
  356         -
                        let container = if let Some(cap) = deser.container_size() {
  357         -
                            Vec::with_capacity(cap)
  358         -
                        } else {
  359         -
                            Vec::new()
  360         -
                        };
  361         -
                        deser.read_list(member, container, |mut list, deser| {
  362         -
                            list.push(crate::types::ScheduledInstancesIpv6Address::deserialize(deser)?);
  363         -
                            Ok(list)
  364         -
                        })?
         346  +
                        let mut container = Vec::new();
         347  +
                        deser.read_list(member, &mut |deser| {
         348  +
                            container.push(crate::types::ScheduledInstancesIpv6Address::deserialize(deser)?);
         349  +
                            Ok(())
         350  +
                        })?;
         351  +
                        container
  365    352   
                    });
  366    353   
                }
  367    354   
                Some(7) => {
  368    355   
                    builder.network_interface_id = Some(deser.read_string(member)?);
  369    356   
                }
  370    357   
                Some(8) => {
  371    358   
                    builder.private_ip_address = Some(deser.read_string(member)?);
  372    359   
                }
  373    360   
                Some(9) => {
  374    361   
                    builder.private_ip_address_configs = Some({
  375         -
                        let container = if let Some(cap) = deser.container_size() {
  376         -
                            Vec::with_capacity(cap)
  377         -
                        } else {
  378         -
                            Vec::new()
  379         -
                        };
  380         -
                        deser.read_list(member, container, |mut list, deser| {
  381         -
                            list.push(crate::types::ScheduledInstancesPrivateIpAddressConfig::deserialize(deser)?);
  382         -
                            Ok(list)
  383         -
                        })?
         362  +
                        let mut container = Vec::new();
         363  +
                        deser.read_list(member, &mut |deser| {
         364  +
                            container.push(crate::types::ScheduledInstancesPrivateIpAddressConfig::deserialize(deser)?);
         365  +
                            Ok(())
         366  +
                        })?;
         367  +
                        container
  384    368   
                    });
  385    369   
                }
  386    370   
                Some(10) => {
  387    371   
                    builder.secondary_private_ip_address_count = Some(deser.read_integer(member)?);
  388    372   
                }
  389    373   
                Some(11) => {
  390    374   
                    builder.subnet_id = Some(deser.read_string(member)?);
  391    375   
                }
  392    376   
                _ => {}
  393    377   
            }
  394    378   
            Ok(())
  395    379   
        })?;
  396    380   
        Ok(builder.build())
  397    381   
    }
  398    382   
}
         383  +
impl ScheduledInstancesNetworkInterface {
         384  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         385  +
    pub fn deserialize_with_response(
         386  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         387  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         388  +
        _status: u16,
         389  +
        _body: &[u8],
         390  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         391  +
        Self::deserialize(deserializer)
         392  +
    }
         393  +
}
  399    394   
impl ScheduledInstancesNetworkInterface {
  400    395   
    /// Creates a new builder-style object to manufacture [`ScheduledInstancesNetworkInterface`](crate::types::ScheduledInstancesNetworkInterface).
  401    396   
    pub fn builder() -> crate::types::builders::ScheduledInstancesNetworkInterfaceBuilder {
  402    397   
        crate::types::builders::ScheduledInstancesNetworkInterfaceBuilder::default()
  403    398   
    }
  404    399   
}
  405    400   
  406    401   
/// A builder for [`ScheduledInstancesNetworkInterface`](crate::types::ScheduledInstancesNetworkInterface).
  407    402   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  408    403   
#[non_exhaustive]

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

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

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

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

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

@@ -45,45 +165,165 @@
   65     65   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.ip_permissions.is_none()`.
   66     66   
    pub fn ip_permissions(&self) -> &[crate::types::IpPermission] {
   67     67   
        self.ip_permissions.as_deref().unwrap_or_default()
   68     68   
    }
   69     69   
}
   70     70   
static SECURITYGROUP_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   71     71   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroup", "com.amazonaws.ec2", "SecurityGroup");
   72     72   
static SECURITYGROUP_MEMBER_GROUP_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroup$GroupId", "com.amazonaws.ec2", "SecurityGroup"),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "group_id",
          75  +
    "GroupId",
   76     76   
    0,
   77     77   
)
   78     78   
.with_xml_name("groupId");
   79     79   
static SECURITYGROUP_MEMBER_IP_PERMISSIONS_EGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.ec2#SecurityGroup$IpPermissionsEgress",
   82     82   
        "com.amazonaws.ec2",
   83     83   
        "SecurityGroup",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::List,
   86         -
    "ip_permissions_egress",
          86  +
    "IpPermissionsEgress",
   87     87   
    1,
   88     88   
)
   89     89   
.with_xml_name("ipPermissionsEgress");
   90     90   
static SECURITYGROUP_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroup$Tags", "com.amazonaws.ec2", "SecurityGroup"),
   92     92   
    ::aws_smithy_schema::ShapeType::List,
   93         -
    "tags",
          93  +
    "Tags",
   94     94   
    2,
   95     95   
)
   96     96   
.with_xml_name("tagSet");
   97     97   
static SECURITYGROUP_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroup$VpcId", "com.amazonaws.ec2", "SecurityGroup"),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "vpc_id",
         100  +
    "VpcId",
  101    101   
    3,
  102    102   
)
  103    103   
.with_xml_name("vpcId");
  104    104   
static SECURITYGROUP_MEMBER_SECURITY_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroup$SecurityGroupArn", "com.amazonaws.ec2", "SecurityGroup"),
  106    106   
    ::aws_smithy_schema::ShapeType::String,
  107         -
    "security_group_arn",
         107  +
    "SecurityGroupArn",
  108    108   
    4,
  109    109   
)
  110    110   
.with_xml_name("securityGroupArn");
  111    111   
static SECURITYGROUP_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroup$OwnerId", "com.amazonaws.ec2", "SecurityGroup"),
  113    113   
    ::aws_smithy_schema::ShapeType::String,
  114         -
    "owner_id",
         114  +
    "OwnerId",
  115    115   
    5,
  116    116   
)
  117    117   
.with_xml_name("ownerId");
  118    118   
static SECURITYGROUP_MEMBER_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroup$GroupName", "com.amazonaws.ec2", "SecurityGroup"),
  120    120   
    ::aws_smithy_schema::ShapeType::String,
  121         -
    "group_name",
         121  +
    "GroupName",
  122    122   
    6,
  123    123   
)
  124    124   
.with_xml_name("groupName");
  125    125   
static SECURITYGROUP_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroup$Description", "com.amazonaws.ec2", "SecurityGroup"),
  127    127   
    ::aws_smithy_schema::ShapeType::String,
  128         -
    "description",
         128  +
    "Description",
  129    129   
    7,
  130    130   
)
  131    131   
.with_xml_name("groupDescription");
  132    132   
static SECURITYGROUP_MEMBER_IP_PERMISSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  133    133   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroup$IpPermissions", "com.amazonaws.ec2", "SecurityGroup"),
  134    134   
    ::aws_smithy_schema::ShapeType::List,
  135         -
    "ip_permissions",
         135  +
    "IpPermissions",
  136    136   
    8,
  137    137   
)
  138    138   
.with_xml_name("ipPermissions");
  139    139   
static SECURITYGROUP_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  140    140   
    SECURITYGROUP_SCHEMA_ID,
  141    141   
    ::aws_smithy_schema::ShapeType::Structure,
  142    142   
    &[
  143    143   
        &SECURITYGROUP_MEMBER_GROUP_ID,
  144    144   
        &SECURITYGROUP_MEMBER_IP_PERMISSIONS_EGRESS,
  145    145   
        &SECURITYGROUP_MEMBER_TAGS,
@@ -190,190 +327,329 @@
  210    210   
                    }
  211    211   
                    Ok(())
  212    212   
                },
  213    213   
            )?;
  214    214   
        }
  215    215   
        Ok(())
  216    216   
    }
  217    217   
}
  218    218   
impl SecurityGroup {
  219    219   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  220         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  221         -
        deserializer: &mut D,
         220  +
    pub fn deserialize(
         221  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  222    222   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  223    223   
        #[allow(unused_variables, unused_mut)]
  224    224   
        let mut builder = Self::builder();
  225    225   
        #[allow(
  226    226   
            unused_variables,
  227    227   
            unreachable_code,
  228    228   
            clippy::single_match,
  229    229   
            clippy::match_single_binding,
  230    230   
            clippy::diverging_sub_expression
  231    231   
        )]
  232         -
        deserializer.read_struct(&SECURITYGROUP_SCHEMA, (), |_, member, deser| {
         232  +
        deserializer.read_struct(&SECURITYGROUP_SCHEMA, &mut |member, deser| {
  233    233   
            match member.member_index() {
  234    234   
                Some(0) => {
  235    235   
                    builder.group_id = Some(deser.read_string(member)?);
  236    236   
                }
  237    237   
                Some(1) => {
  238    238   
                    builder.ip_permissions_egress = Some({
  239         -
                        let container = if let Some(cap) = deser.container_size() {
  240         -
                            Vec::with_capacity(cap)
  241         -
                        } else {
  242         -
                            Vec::new()
  243         -
                        };
  244         -
                        deser.read_list(member, container, |mut list, deser| {
  245         -
                            list.push(crate::types::IpPermission::deserialize(deser)?);
  246         -
                            Ok(list)
  247         -
                        })?
         239  +
                        let mut container = Vec::new();
         240  +
                        deser.read_list(member, &mut |deser| {
         241  +
                            container.push(crate::types::IpPermission::deserialize(deser)?);
         242  +
                            Ok(())
         243  +
                        })?;
         244  +
                        container
  248    245   
                    });
  249    246   
                }
  250    247   
                Some(2) => {
  251    248   
                    builder.tags = Some({
  252         -
                        let container = if let Some(cap) = deser.container_size() {
  253         -
                            Vec::with_capacity(cap)
  254         -
                        } else {
  255         -
                            Vec::new()
  256         -
                        };
  257         -
                        deser.read_list(member, container, |mut list, deser| {
  258         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  259         -
                            Ok(list)
  260         -
                        })?
         249  +
                        let mut container = Vec::new();
         250  +
                        deser.read_list(member, &mut |deser| {
         251  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         252  +
                            Ok(())
         253  +
                        })?;
         254  +
                        container
  261    255   
                    });
  262    256   
                }
  263    257   
                Some(3) => {
  264    258   
                    builder.vpc_id = Some(deser.read_string(member)?);
  265    259   
                }
  266    260   
                Some(4) => {
  267    261   
                    builder.security_group_arn = Some(deser.read_string(member)?);
  268    262   
                }
  269    263   
                Some(5) => {
  270    264   
                    builder.owner_id = Some(deser.read_string(member)?);
  271    265   
                }
  272    266   
                Some(6) => {
  273    267   
                    builder.group_name = Some(deser.read_string(member)?);
  274    268   
                }
  275    269   
                Some(7) => {
  276    270   
                    builder.description = Some(deser.read_string(member)?);
  277    271   
                }
  278    272   
                Some(8) => {
  279    273   
                    builder.ip_permissions = Some({
  280         -
                        let container = if let Some(cap) = deser.container_size() {
  281         -
                            Vec::with_capacity(cap)
  282         -
                        } else {
  283         -
                            Vec::new()
  284         -
                        };
  285         -
                        deser.read_list(member, container, |mut list, deser| {
  286         -
                            list.push(crate::types::IpPermission::deserialize(deser)?);
  287         -
                            Ok(list)
  288         -
                        })?
         274  +
                        let mut container = Vec::new();
         275  +
                        deser.read_list(member, &mut |deser| {
         276  +
                            container.push(crate::types::IpPermission::deserialize(deser)?);
         277  +
                            Ok(())
         278  +
                        })?;
         279  +
                        container
  289    280   
                    });
  290    281   
                }
  291    282   
                _ => {}
  292    283   
            }
  293    284   
            Ok(())
  294    285   
        })?;
  295    286   
        Ok(builder.build())
  296    287   
    }
  297    288   
}
         289  +
impl SecurityGroup {
         290  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         291  +
    pub fn deserialize_with_response(
         292  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         293  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         294  +
        _status: u16,
         295  +
        _body: &[u8],
         296  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         297  +
        Self::deserialize(deserializer)
         298  +
    }
         299  +
}
  298    300   
impl SecurityGroup {
  299    301   
    /// Creates a new builder-style object to manufacture [`SecurityGroup`](crate::types::SecurityGroup).
  300    302   
    pub fn builder() -> crate::types::builders::SecurityGroupBuilder {
  301    303   
        crate::types::builders::SecurityGroupBuilder::default()
  302    304   
    }
  303    305   
}
  304    306   
  305    307   
/// A builder for [`SecurityGroup`](crate::types::SecurityGroup).
  306    308   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  307    309   
#[non_exhaustive]

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

@@ -27,27 +243,251 @@
   47     47   
}
   48     48   
static SECURITYGROUPFORVPC_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroupForVpc", "com.amazonaws.ec2", "SecurityGroupForVpc");
   50     50   
static SECURITYGROUPFORVPC_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.ec2#SecurityGroupForVpc$Description",
   53     53   
        "com.amazonaws.ec2",
   54     54   
        "SecurityGroupForVpc",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "description",
          57  +
    "Description",
   58     58   
    0,
   59     59   
)
   60     60   
.with_xml_name("description");
   61     61   
static SECURITYGROUPFORVPC_MEMBER_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.ec2#SecurityGroupForVpc$GroupName",
   64     64   
        "com.amazonaws.ec2",
   65     65   
        "SecurityGroupForVpc",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::String,
   68         -
    "group_name",
          68  +
    "GroupName",
   69     69   
    1,
   70     70   
)
   71     71   
.with_xml_name("groupName");
   72     72   
static SECURITYGROUPFORVPC_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.ec2#SecurityGroupForVpc$OwnerId",
   75     75   
        "com.amazonaws.ec2",
   76     76   
        "SecurityGroupForVpc",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "owner_id",
          79  +
    "OwnerId",
   80     80   
    2,
   81     81   
)
   82     82   
.with_xml_name("ownerId");
   83     83   
static SECURITYGROUPFORVPC_MEMBER_GROUP_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.ec2#SecurityGroupForVpc$GroupId",
   86     86   
        "com.amazonaws.ec2",
   87     87   
        "SecurityGroupForVpc",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "group_id",
          90  +
    "GroupId",
   91     91   
    3,
   92     92   
)
   93     93   
.with_xml_name("groupId");
   94     94   
static SECURITYGROUPFORVPC_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroupForVpc$Tags", "com.amazonaws.ec2", "SecurityGroupForVpc"),
   96     96   
    ::aws_smithy_schema::ShapeType::List,
   97         -
    "tags",
          97  +
    "Tags",
   98     98   
    4,
   99     99   
)
  100    100   
.with_xml_name("tagSet");
  101    101   
static SECURITYGROUPFORVPC_MEMBER_PRIMARY_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.ec2#SecurityGroupForVpc$PrimaryVpcId",
  104    104   
        "com.amazonaws.ec2",
  105    105   
        "SecurityGroupForVpc",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "primary_vpc_id",
         108  +
    "PrimaryVpcId",
  109    109   
    5,
  110    110   
)
  111    111   
.with_xml_name("primaryVpcId");
  112    112   
static SECURITYGROUPFORVPC_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  113    113   
    SECURITYGROUPFORVPC_SCHEMA_ID,
  114    114   
    ::aws_smithy_schema::ShapeType::Structure,
  115    115   
    &[
  116    116   
        &SECURITYGROUPFORVPC_MEMBER_DESCRIPTION,
  117    117   
        &SECURITYGROUPFORVPC_MEMBER_GROUP_NAME,
  118    118   
        &SECURITYGROUPFORVPC_MEMBER_OWNER_ID,
  119    119   
        &SECURITYGROUPFORVPC_MEMBER_GROUP_ID,
  120    120   
        &SECURITYGROUPFORVPC_MEMBER_TAGS,
  121    121   
        &SECURITYGROUPFORVPC_MEMBER_PRIMARY_VPC_ID,
  122    122   
    ],
  123    123   
);
  124    124   
impl SecurityGroupForVpc {
  125    125   
    /// The schema for this shape.
  126    126   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SECURITYGROUPFORVPC_SCHEMA;
  127    127   
}
  128    128   
impl ::aws_smithy_schema::serde::SerializableStruct for SecurityGroupForVpc {
  129    129   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  130    130   
    fn serialize_members(
  131    131   
        &self,
  132    132   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  133    133   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  134    134   
        if let Some(ref val) = self.description {
  135    135   
            ser.write_string(&SECURITYGROUPFORVPC_MEMBER_DESCRIPTION, val)?;
  136    136   
        }
  137    137   
        if let Some(ref val) = self.group_name {
  138    138   
            ser.write_string(&SECURITYGROUPFORVPC_MEMBER_GROUP_NAME, val)?;
  139    139   
        }
  140    140   
        if let Some(ref val) = self.owner_id {
  141    141   
            ser.write_string(&SECURITYGROUPFORVPC_MEMBER_OWNER_ID, val)?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.group_id {
  144    144   
            ser.write_string(&SECURITYGROUPFORVPC_MEMBER_GROUP_ID, val)?;
  145    145   
        }
  146    146   
        if let Some(ref val) = self.tags {
  147    147   
            ser.write_list(
  148    148   
                &SECURITYGROUPFORVPC_MEMBER_TAGS,
  149    149   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  150    150   
                    for item in val {
  151    151   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  152    152   
                    }
  153    153   
                    Ok(())
  154    154   
                },
  155    155   
            )?;
  156    156   
        }
  157    157   
        if let Some(ref val) = self.primary_vpc_id {
  158    158   
            ser.write_string(&SECURITYGROUPFORVPC_MEMBER_PRIMARY_VPC_ID, val)?;
  159    159   
        }
  160    160   
        Ok(())
  161    161   
    }
  162    162   
}
  163    163   
impl SecurityGroupForVpc {
  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(&SECURITYGROUPFORVPC_SCHEMA, (), |_, member, deser| {
         177  +
        deserializer.read_struct(&SECURITYGROUPFORVPC_SCHEMA, &mut |member, deser| {
  178    178   
            match member.member_index() {
  179    179   
                Some(0) => {
  180    180   
                    builder.description = Some(deser.read_string(member)?);
  181    181   
                }
  182    182   
                Some(1) => {
  183    183   
                    builder.group_name = Some(deser.read_string(member)?);
  184    184   
                }
  185    185   
                Some(2) => {
  186    186   
                    builder.owner_id = Some(deser.read_string(member)?);
  187    187   
                }
  188    188   
                Some(3) => {
  189    189   
                    builder.group_id = Some(deser.read_string(member)?);
  190    190   
                }
  191    191   
                Some(4) => {
  192    192   
                    builder.tags = Some({
  193         -
                        let container = if let Some(cap) = deser.container_size() {
  194         -
                            Vec::with_capacity(cap)
  195         -
                        } else {
  196         -
                            Vec::new()
  197         -
                        };
  198         -
                        deser.read_list(member, container, |mut list, deser| {
  199         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  200         -
                            Ok(list)
  201         -
                        })?
         193  +
                        let mut container = Vec::new();
         194  +
                        deser.read_list(member, &mut |deser| {
         195  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         196  +
                            Ok(())
         197  +
                        })?;
         198  +
                        container
  202    199   
                    });
  203    200   
                }
  204    201   
                Some(5) => {
  205    202   
                    builder.primary_vpc_id = Some(deser.read_string(member)?);
  206    203   
                }
  207    204   
                _ => {}
  208    205   
            }
  209    206   
            Ok(())
  210    207   
        })?;
  211    208   
        Ok(builder.build())
  212    209   
    }
  213    210   
}
         211  +
impl SecurityGroupForVpc {
         212  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         213  +
    pub fn deserialize_with_response(
         214  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         215  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         216  +
        _status: u16,
         217  +
        _body: &[u8],
         218  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         219  +
        Self::deserialize(deserializer)
         220  +
    }
         221  +
}
  214    222   
impl SecurityGroupForVpc {
  215    223   
    /// Creates a new builder-style object to manufacture [`SecurityGroupForVpc`](crate::types::SecurityGroupForVpc).
  216    224   
    pub fn builder() -> crate::types::builders::SecurityGroupForVpcBuilder {
  217    225   
        crate::types::builders::SecurityGroupForVpcBuilder::default()
  218    226   
    }
  219    227   
}
  220    228   
  221    229   
/// A builder for [`SecurityGroupForVpc`](crate::types::SecurityGroupForVpc).
  222    230   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  223    231   
#[non_exhaustive]

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

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

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

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

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

@@ -77,77 +248,248 @@
   97     97   
}
   98     98   
static SECURITYGROUPRULE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   99     99   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroupRule", "com.amazonaws.ec2", "SecurityGroupRule");
  100    100   
static SECURITYGROUPRULE_MEMBER_SECURITY_GROUP_RULE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.ec2#SecurityGroupRule$SecurityGroupRuleId",
  103    103   
        "com.amazonaws.ec2",
  104    104   
        "SecurityGroupRule",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::String,
  107         -
    "security_group_rule_id",
         107  +
    "SecurityGroupRuleId",
  108    108   
    0,
  109    109   
)
  110    110   
.with_xml_name("securityGroupRuleId");
  111    111   
static SECURITYGROUPRULE_MEMBER_GROUP_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroupRule$GroupId", "com.amazonaws.ec2", "SecurityGroupRule"),
  113    113   
    ::aws_smithy_schema::ShapeType::String,
  114         -
    "group_id",
         114  +
    "GroupId",
  115    115   
    1,
  116    116   
)
  117    117   
.with_xml_name("groupId");
  118    118   
static SECURITYGROUPRULE_MEMBER_GROUP_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.ec2#SecurityGroupRule$GroupOwnerId",
  121    121   
        "com.amazonaws.ec2",
  122    122   
        "SecurityGroupRule",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::String,
  125         -
    "group_owner_id",
         125  +
    "GroupOwnerId",
  126    126   
    2,
  127    127   
)
  128    128   
.with_xml_name("groupOwnerId");
  129    129   
static SECURITYGROUPRULE_MEMBER_IS_EGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroupRule$IsEgress", "com.amazonaws.ec2", "SecurityGroupRule"),
  131    131   
    ::aws_smithy_schema::ShapeType::Boolean,
  132         -
    "is_egress",
         132  +
    "IsEgress",
  133    133   
    3,
  134    134   
)
  135    135   
.with_xml_name("isEgress");
  136    136   
static SECURITYGROUPRULE_MEMBER_IP_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  137    137   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroupRule$IpProtocol", "com.amazonaws.ec2", "SecurityGroupRule"),
  138    138   
    ::aws_smithy_schema::ShapeType::String,
  139         -
    "ip_protocol",
         139  +
    "IpProtocol",
  140    140   
    4,
  141    141   
)
  142    142   
.with_xml_name("ipProtocol");
  143    143   
static SECURITYGROUPRULE_MEMBER_FROM_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  144    144   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroupRule$FromPort", "com.amazonaws.ec2", "SecurityGroupRule"),
  145    145   
    ::aws_smithy_schema::ShapeType::Integer,
  146         -
    "from_port",
         146  +
    "FromPort",
  147    147   
    5,
  148    148   
)
  149    149   
.with_xml_name("fromPort");
  150    150   
static SECURITYGROUPRULE_MEMBER_TO_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  151    151   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroupRule$ToPort", "com.amazonaws.ec2", "SecurityGroupRule"),
  152    152   
    ::aws_smithy_schema::ShapeType::Integer,
  153         -
    "to_port",
         153  +
    "ToPort",
  154    154   
    6,
  155    155   
)
  156    156   
.with_xml_name("toPort");
  157    157   
static SECURITYGROUPRULE_MEMBER_CIDR_IPV4: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  158    158   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroupRule$CidrIpv4", "com.amazonaws.ec2", "SecurityGroupRule"),
  159    159   
    ::aws_smithy_schema::ShapeType::String,
  160         -
    "cidr_ipv4",
         160  +
    "CidrIpv4",
  161    161   
    7,
  162    162   
)
  163    163   
.with_xml_name("cidrIpv4");
  164    164   
static SECURITYGROUPRULE_MEMBER_CIDR_IPV6: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  165    165   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroupRule$CidrIpv6", "com.amazonaws.ec2", "SecurityGroupRule"),
  166    166   
    ::aws_smithy_schema::ShapeType::String,
  167         -
    "cidr_ipv6",
         167  +
    "CidrIpv6",
  168    168   
    8,
  169    169   
)
  170    170   
.with_xml_name("cidrIpv6");
  171    171   
static SECURITYGROUPRULE_MEMBER_PREFIX_LIST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  172    172   
    ::aws_smithy_schema::ShapeId::from_static(
  173    173   
        "com.amazonaws.ec2#SecurityGroupRule$PrefixListId",
  174    174   
        "com.amazonaws.ec2",
  175    175   
        "SecurityGroupRule",
  176    176   
    ),
  177    177   
    ::aws_smithy_schema::ShapeType::String,
  178         -
    "prefix_list_id",
         178  +
    "PrefixListId",
  179    179   
    9,
  180    180   
)
  181    181   
.with_xml_name("prefixListId");
  182    182   
static SECURITYGROUPRULE_MEMBER_REFERENCED_GROUP_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  183    183   
    ::aws_smithy_schema::ShapeId::from_static(
  184    184   
        "com.amazonaws.ec2#SecurityGroupRule$ReferencedGroupInfo",
  185    185   
        "com.amazonaws.ec2",
  186    186   
        "SecurityGroupRule",
  187    187   
    ),
  188    188   
    ::aws_smithy_schema::ShapeType::Structure,
  189         -
    "referenced_group_info",
         189  +
    "ReferencedGroupInfo",
  190    190   
    10,
  191    191   
)
  192    192   
.with_xml_name("referencedGroupInfo");
  193    193   
static SECURITYGROUPRULE_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  194    194   
    ::aws_smithy_schema::ShapeId::from_static(
  195    195   
        "com.amazonaws.ec2#SecurityGroupRule$Description",
  196    196   
        "com.amazonaws.ec2",
  197    197   
        "SecurityGroupRule",
  198    198   
    ),
  199    199   
    ::aws_smithy_schema::ShapeType::String,
  200         -
    "description",
         200  +
    "Description",
  201    201   
    11,
  202    202   
)
  203    203   
.with_xml_name("description");
  204    204   
static SECURITYGROUPRULE_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  205    205   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#SecurityGroupRule$Tags", "com.amazonaws.ec2", "SecurityGroupRule"),
  206    206   
    ::aws_smithy_schema::ShapeType::List,
  207         -
    "tags",
         207  +
    "Tags",
  208    208   
    12,
  209    209   
)
  210    210   
.with_xml_name("tagSet");
  211    211   
static SECURITYGROUPRULE_MEMBER_SECURITY_GROUP_RULE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  212    212   
    ::aws_smithy_schema::ShapeId::from_static(
  213    213   
        "com.amazonaws.ec2#SecurityGroupRule$SecurityGroupRuleArn",
  214    214   
        "com.amazonaws.ec2",
  215    215   
        "SecurityGroupRule",
  216    216   
    ),
  217    217   
    ::aws_smithy_schema::ShapeType::String,
  218         -
    "security_group_rule_arn",
         218  +
    "SecurityGroupRuleArn",
  219    219   
    13,
  220    220   
)
  221    221   
.with_xml_name("securityGroupRuleArn");
  222    222   
static SECURITYGROUPRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  223    223   
    SECURITYGROUPRULE_SCHEMA_ID,
  224    224   
    ::aws_smithy_schema::ShapeType::Structure,
  225    225   
    &[
  226    226   
        &SECURITYGROUPRULE_MEMBER_SECURITY_GROUP_RULE_ID,
  227    227   
        &SECURITYGROUPRULE_MEMBER_GROUP_ID,
  228    228   
        &SECURITYGROUPRULE_MEMBER_GROUP_OWNER_ID,
@@ -277,277 +409,417 @@
  297    297   
            )?;
  298    298   
        }
  299    299   
        if let Some(ref val) = self.security_group_rule_arn {
  300    300   
            ser.write_string(&SECURITYGROUPRULE_MEMBER_SECURITY_GROUP_RULE_ARN, val)?;
  301    301   
        }
  302    302   
        Ok(())
  303    303   
    }
  304    304   
}
  305    305   
impl SecurityGroupRule {
  306    306   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  307         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  308         -
        deserializer: &mut D,
         307  +
    pub fn deserialize(
         308  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  309    309   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  310    310   
        #[allow(unused_variables, unused_mut)]
  311    311   
        let mut builder = Self::builder();
  312    312   
        #[allow(
  313    313   
            unused_variables,
  314    314   
            unreachable_code,
  315    315   
            clippy::single_match,
  316    316   
            clippy::match_single_binding,
  317    317   
            clippy::diverging_sub_expression
  318    318   
        )]
  319         -
        deserializer.read_struct(&SECURITYGROUPRULE_SCHEMA, (), |_, member, deser| {
         319  +
        deserializer.read_struct(&SECURITYGROUPRULE_SCHEMA, &mut |member, deser| {
  320    320   
            match member.member_index() {
  321    321   
                Some(0) => {
  322    322   
                    builder.security_group_rule_id = Some(deser.read_string(member)?);
  323    323   
                }
  324    324   
                Some(1) => {
  325    325   
                    builder.group_id = Some(deser.read_string(member)?);
  326    326   
                }
  327    327   
                Some(2) => {
  328    328   
                    builder.group_owner_id = Some(deser.read_string(member)?);
  329    329   
                }
  330    330   
                Some(3) => {
  331    331   
                    builder.is_egress = Some(deser.read_boolean(member)?);
  332    332   
                }
  333    333   
                Some(4) => {
  334    334   
                    builder.ip_protocol = Some(deser.read_string(member)?);
  335    335   
                }
  336    336   
                Some(5) => {
  337    337   
                    builder.from_port = Some(deser.read_integer(member)?);
  338    338   
                }
  339    339   
                Some(6) => {
  340    340   
                    builder.to_port = Some(deser.read_integer(member)?);
  341    341   
                }
  342    342   
                Some(7) => {
  343    343   
                    builder.cidr_ipv4 = Some(deser.read_string(member)?);
  344    344   
                }
  345    345   
                Some(8) => {
  346    346   
                    builder.cidr_ipv6 = Some(deser.read_string(member)?);
  347    347   
                }
  348    348   
                Some(9) => {
  349    349   
                    builder.prefix_list_id = Some(deser.read_string(member)?);
  350    350   
                }
  351    351   
                Some(10) => {
  352    352   
                    builder.referenced_group_info = Some(crate::types::ReferencedSecurityGroup::deserialize(deser)?);
  353    353   
                }
  354    354   
                Some(11) => {
  355    355   
                    builder.description = Some(deser.read_string(member)?);
  356    356   
                }
  357    357   
                Some(12) => {
  358    358   
                    builder.tags = Some({
  359         -
                        let container = if let Some(cap) = deser.container_size() {
  360         -
                            Vec::with_capacity(cap)
  361         -
                        } else {
  362         -
                            Vec::new()
  363         -
                        };
  364         -
                        deser.read_list(member, container, |mut list, deser| {
  365         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  366         -
                            Ok(list)
  367         -
                        })?
         359  +
                        let mut container = Vec::new();
         360  +
                        deser.read_list(member, &mut |deser| {
         361  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         362  +
                            Ok(())
         363  +
                        })?;
         364  +
                        container
  368    365   
                    });
  369    366   
                }
  370    367   
                Some(13) => {
  371    368   
                    builder.security_group_rule_arn = Some(deser.read_string(member)?);
  372    369   
                }
  373    370   
                _ => {}
  374    371   
            }
  375    372   
            Ok(())
  376    373   
        })?;
  377    374   
        Ok(builder.build())
  378    375   
    }
  379    376   
}
         377  +
impl SecurityGroupRule {
         378  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         379  +
    pub fn deserialize_with_response(
         380  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         381  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         382  +
        _status: u16,
         383  +
        _body: &[u8],
         384  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         385  +
        Self::deserialize(deserializer)
         386  +
    }
         387  +
}
  380    388   
impl SecurityGroupRule {
  381    389   
    /// Creates a new builder-style object to manufacture [`SecurityGroupRule`](crate::types::SecurityGroupRule).
  382    390   
    pub fn builder() -> crate::types::builders::SecurityGroupRuleBuilder {
  383    391   
        crate::types::builders::SecurityGroupRuleBuilder::default()
  384    392   
    }
  385    393   
}
  386    394   
  387    395   
/// A builder for [`SecurityGroupRule`](crate::types::SecurityGroupRule).
  388    396   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  389    397   
#[non_exhaustive]

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

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

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

@@ -56,56 +286,297 @@
   76     76   
    "com.amazonaws.ec2",
   77     77   
    "SecurityGroupRuleRequest",
   78     78   
);
   79     79   
static SECURITYGROUPRULEREQUEST_MEMBER_IP_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.ec2#SecurityGroupRuleRequest$IpProtocol",
   82     82   
        "com.amazonaws.ec2",
   83     83   
        "SecurityGroupRuleRequest",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86         -
    "ip_protocol",
          86  +
    "IpProtocol",
   87     87   
    0,
   88     88   
);
   89     89   
static SECURITYGROUPRULEREQUEST_MEMBER_FROM_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.ec2#SecurityGroupRuleRequest$FromPort",
   92     92   
        "com.amazonaws.ec2",
   93     93   
        "SecurityGroupRuleRequest",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::Integer,
   96         -
    "from_port",
          96  +
    "FromPort",
   97     97   
    1,
   98     98   
);
   99     99   
static SECURITYGROUPRULEREQUEST_MEMBER_TO_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.ec2#SecurityGroupRuleRequest$ToPort",
  102    102   
        "com.amazonaws.ec2",
  103    103   
        "SecurityGroupRuleRequest",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::Integer,
  106         -
    "to_port",
         106  +
    "ToPort",
  107    107   
    2,
  108    108   
);
  109    109   
static SECURITYGROUPRULEREQUEST_MEMBER_CIDR_IPV4: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.ec2#SecurityGroupRuleRequest$CidrIpv4",
  112    112   
        "com.amazonaws.ec2",
  113    113   
        "SecurityGroupRuleRequest",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "cidr_ipv4",
         116  +
    "CidrIpv4",
  117    117   
    3,
  118    118   
);
  119    119   
static SECURITYGROUPRULEREQUEST_MEMBER_CIDR_IPV6: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.ec2#SecurityGroupRuleRequest$CidrIpv6",
  122    122   
        "com.amazonaws.ec2",
  123    123   
        "SecurityGroupRuleRequest",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::String,
  126         -
    "cidr_ipv6",
         126  +
    "CidrIpv6",
  127    127   
    4,
  128    128   
);
  129    129   
static SECURITYGROUPRULEREQUEST_MEMBER_PREFIX_LIST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static(
  131    131   
        "com.amazonaws.ec2#SecurityGroupRuleRequest$PrefixListId",
  132    132   
        "com.amazonaws.ec2",
  133    133   
        "SecurityGroupRuleRequest",
  134    134   
    ),
  135    135   
    ::aws_smithy_schema::ShapeType::String,
  136         -
    "prefix_list_id",
         136  +
    "PrefixListId",
  137    137   
    5,
  138    138   
);
  139    139   
static SECURITYGROUPRULEREQUEST_MEMBER_REFERENCED_GROUP_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static(
  141    141   
        "com.amazonaws.ec2#SecurityGroupRuleRequest$ReferencedGroupId",
  142    142   
        "com.amazonaws.ec2",
  143    143   
        "SecurityGroupRuleRequest",
  144    144   
    ),
  145    145   
    ::aws_smithy_schema::ShapeType::String,
  146         -
    "referenced_group_id",
         146  +
    "ReferencedGroupId",
  147    147   
    6,
  148    148   
);
  149    149   
static SECURITYGROUPRULEREQUEST_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static(
  151    151   
        "com.amazonaws.ec2#SecurityGroupRuleRequest$Description",
  152    152   
        "com.amazonaws.ec2",
  153    153   
        "SecurityGroupRuleRequest",
  154    154   
    ),
  155    155   
    ::aws_smithy_schema::ShapeType::String,
  156         -
    "description",
         156  +
    "Description",
  157    157   
    7,
  158    158   
);
  159    159   
static SECURITYGROUPRULEREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  160    160   
    SECURITYGROUPRULEREQUEST_SCHEMA_ID,
  161    161   
    ::aws_smithy_schema::ShapeType::Structure,
  162    162   
    &[
  163    163   
        &SECURITYGROUPRULEREQUEST_MEMBER_IP_PROTOCOL,
  164    164   
        &SECURITYGROUPRULEREQUEST_MEMBER_FROM_PORT,
  165    165   
        &SECURITYGROUPRULEREQUEST_MEMBER_TO_PORT,
  166    166   
        &SECURITYGROUPRULEREQUEST_MEMBER_CIDR_IPV4,
  167    167   
        &SECURITYGROUPRULEREQUEST_MEMBER_CIDR_IPV6,
  168    168   
        &SECURITYGROUPRULEREQUEST_MEMBER_PREFIX_LIST_ID,
  169    169   
        &SECURITYGROUPRULEREQUEST_MEMBER_REFERENCED_GROUP_ID,
  170    170   
        &SECURITYGROUPRULEREQUEST_MEMBER_DESCRIPTION,
  171    171   
    ],
  172    172   
);
  173    173   
impl SecurityGroupRuleRequest {
  174    174   
    /// The schema for this shape.
  175    175   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SECURITYGROUPRULEREQUEST_SCHEMA;
  176    176   
}
  177    177   
impl ::aws_smithy_schema::serde::SerializableStruct for SecurityGroupRuleRequest {
  178    178   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  179    179   
    fn serialize_members(
  180    180   
        &self,
  181    181   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  182    182   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  183    183   
        if let Some(ref val) = self.ip_protocol {
  184    184   
            ser.write_string(&SECURITYGROUPRULEREQUEST_MEMBER_IP_PROTOCOL, val)?;
  185    185   
        }
  186    186   
        if let Some(ref val) = self.from_port {
  187    187   
            ser.write_integer(&SECURITYGROUPRULEREQUEST_MEMBER_FROM_PORT, *val)?;
  188    188   
        }
  189    189   
        if let Some(ref val) = self.to_port {
  190    190   
            ser.write_integer(&SECURITYGROUPRULEREQUEST_MEMBER_TO_PORT, *val)?;
  191    191   
        }
  192    192   
        if let Some(ref val) = self.cidr_ipv4 {
  193    193   
            ser.write_string(&SECURITYGROUPRULEREQUEST_MEMBER_CIDR_IPV4, val)?;
  194    194   
        }
  195    195   
        if let Some(ref val) = self.cidr_ipv6 {
  196    196   
            ser.write_string(&SECURITYGROUPRULEREQUEST_MEMBER_CIDR_IPV6, val)?;
  197    197   
        }
  198    198   
        if let Some(ref val) = self.prefix_list_id {
  199    199   
            ser.write_string(&SECURITYGROUPRULEREQUEST_MEMBER_PREFIX_LIST_ID, val)?;
  200    200   
        }
  201    201   
        if let Some(ref val) = self.referenced_group_id {
  202    202   
            ser.write_string(&SECURITYGROUPRULEREQUEST_MEMBER_REFERENCED_GROUP_ID, val)?;
  203    203   
        }
  204    204   
        if let Some(ref val) = self.description {
  205    205   
            ser.write_string(&SECURITYGROUPRULEREQUEST_MEMBER_DESCRIPTION, val)?;
  206    206   
        }
  207    207   
        Ok(())
  208    208   
    }
  209    209   
}
  210    210   
impl SecurityGroupRuleRequest {
  211    211   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  212         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  213         -
        deserializer: &mut D,
         212  +
    pub fn deserialize(
         213  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  214    214   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  215    215   
        #[allow(unused_variables, unused_mut)]
  216    216   
        let mut builder = Self::builder();
  217    217   
        #[allow(
  218    218   
            unused_variables,
  219    219   
            unreachable_code,
  220    220   
            clippy::single_match,
  221    221   
            clippy::match_single_binding,
  222    222   
            clippy::diverging_sub_expression
  223    223   
        )]
  224         -
        deserializer.read_struct(&SECURITYGROUPRULEREQUEST_SCHEMA, (), |_, member, deser| {
         224  +
        deserializer.read_struct(&SECURITYGROUPRULEREQUEST_SCHEMA, &mut |member, deser| {
  225    225   
            match member.member_index() {
  226    226   
                Some(0) => {
  227    227   
                    builder.ip_protocol = Some(deser.read_string(member)?);
  228    228   
                }
  229    229   
                Some(1) => {
  230    230   
                    builder.from_port = Some(deser.read_integer(member)?);
  231    231   
                }
  232    232   
                Some(2) => {
  233    233   
                    builder.to_port = Some(deser.read_integer(member)?);
  234    234   
                }
  235    235   
                Some(3) => {
  236    236   
                    builder.cidr_ipv4 = Some(deser.read_string(member)?);
  237    237   
                }
  238    238   
                Some(4) => {
  239    239   
                    builder.cidr_ipv6 = Some(deser.read_string(member)?);
  240    240   
                }
  241    241   
                Some(5) => {
  242    242   
                    builder.prefix_list_id = Some(deser.read_string(member)?);
  243    243   
                }
  244    244   
                Some(6) => {
  245    245   
                    builder.referenced_group_id = Some(deser.read_string(member)?);
  246    246   
                }
  247    247   
                Some(7) => {
  248    248   
                    builder.description = Some(deser.read_string(member)?);
  249    249   
                }
  250    250   
                _ => {}
  251    251   
            }
  252    252   
            Ok(())
  253    253   
        })?;
  254    254   
        Ok(builder.build())
  255    255   
    }
  256    256   
}
         257  +
impl SecurityGroupRuleRequest {
         258  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         259  +
    pub fn deserialize_with_response(
         260  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         261  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         262  +
        _status: u16,
         263  +
        _body: &[u8],
         264  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         265  +
        Self::deserialize(deserializer)
         266  +
    }
         267  +
}
  257    268   
impl SecurityGroupRuleRequest {
  258    269   
    /// Creates a new builder-style object to manufacture [`SecurityGroupRuleRequest`](crate::types::SecurityGroupRuleRequest).
  259    270   
    pub fn builder() -> crate::types::builders::SecurityGroupRuleRequestBuilder {
  260    271   
        crate::types::builders::SecurityGroupRuleRequestBuilder::default()
  261    272   
    }
  262    273   
}
  263    274   
  264    275   
/// A builder for [`SecurityGroupRuleRequest`](crate::types::SecurityGroupRuleRequest).
  265    276   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  266    277   
#[non_exhaustive]

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

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