AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045

Files changed:

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

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

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

@@ -54,54 +184,184 @@
   74     74   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
   75     75   
    pub fn tags(&self) -> &[crate::types::Tag] {
   76     76   
        self.tags.as_deref().unwrap_or_default()
   77     77   
    }
   78     78   
}
   79     79   
static IPAMSCOPE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   80     80   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IpamScope", "com.amazonaws.ec2", "IpamScope");
   81     81   
static IPAMSCOPE_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IpamScope$OwnerId", "com.amazonaws.ec2", "IpamScope"),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "owner_id",
          84  +
    "OwnerId",
   85     85   
    0,
   86     86   
)
   87     87   
.with_xml_name("ownerId");
   88     88   
static IPAMSCOPE_MEMBER_IPAM_SCOPE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IpamScope$IpamScopeId", "com.amazonaws.ec2", "IpamScope"),
   90     90   
    ::aws_smithy_schema::ShapeType::String,
   91         -
    "ipam_scope_id",
          91  +
    "IpamScopeId",
   92     92   
    1,
   93     93   
)
   94     94   
.with_xml_name("ipamScopeId");
   95     95   
static IPAMSCOPE_MEMBER_IPAM_SCOPE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IpamScope$IpamScopeArn", "com.amazonaws.ec2", "IpamScope"),
   97     97   
    ::aws_smithy_schema::ShapeType::String,
   98         -
    "ipam_scope_arn",
          98  +
    "IpamScopeArn",
   99     99   
    2,
  100    100   
)
  101    101   
.with_xml_name("ipamScopeArn");
  102    102   
static IPAMSCOPE_MEMBER_IPAM_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IpamScope$IpamArn", "com.amazonaws.ec2", "IpamScope"),
  104    104   
    ::aws_smithy_schema::ShapeType::String,
  105         -
    "ipam_arn",
         105  +
    "IpamArn",
  106    106   
    3,
  107    107   
)
  108    108   
.with_xml_name("ipamArn");
  109    109   
static IPAMSCOPE_MEMBER_IPAM_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IpamScope$IpamRegion", "com.amazonaws.ec2", "IpamScope"),
  111    111   
    ::aws_smithy_schema::ShapeType::String,
  112         -
    "ipam_region",
         112  +
    "IpamRegion",
  113    113   
    4,
  114    114   
)
  115    115   
.with_xml_name("ipamRegion");
  116    116   
static IPAMSCOPE_MEMBER_IPAM_SCOPE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  117    117   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IpamScope$IpamScopeType", "com.amazonaws.ec2", "IpamScope"),
  118    118   
    ::aws_smithy_schema::ShapeType::String,
  119         -
    "ipam_scope_type",
         119  +
    "IpamScopeType",
  120    120   
    5,
  121    121   
)
  122    122   
.with_xml_name("ipamScopeType");
  123    123   
static IPAMSCOPE_MEMBER_IS_DEFAULT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IpamScope$IsDefault", "com.amazonaws.ec2", "IpamScope"),
  125    125   
    ::aws_smithy_schema::ShapeType::Boolean,
  126         -
    "is_default",
         126  +
    "IsDefault",
  127    127   
    6,
  128    128   
)
  129    129   
.with_xml_name("isDefault");
  130    130   
static IPAMSCOPE_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IpamScope$Description", "com.amazonaws.ec2", "IpamScope"),
  132    132   
    ::aws_smithy_schema::ShapeType::String,
  133         -
    "description",
         133  +
    "Description",
  134    134   
    7,
  135    135   
)
  136    136   
.with_xml_name("description");
  137    137   
static IPAMSCOPE_MEMBER_POOL_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IpamScope$PoolCount", "com.amazonaws.ec2", "IpamScope"),
  139    139   
    ::aws_smithy_schema::ShapeType::Integer,
  140         -
    "pool_count",
         140  +
    "PoolCount",
  141    141   
    8,
  142    142   
)
  143    143   
.with_xml_name("poolCount");
  144    144   
static IPAMSCOPE_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IpamScope$State", "com.amazonaws.ec2", "IpamScope"),
  146    146   
    ::aws_smithy_schema::ShapeType::String,
  147         -
    "state",
         147  +
    "State",
  148    148   
    9,
  149    149   
)
  150    150   
.with_xml_name("state");
  151    151   
static IPAMSCOPE_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  152    152   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IpamScope$Tags", "com.amazonaws.ec2", "IpamScope"),
  153    153   
    ::aws_smithy_schema::ShapeType::List,
  154         -
    "tags",
         154  +
    "Tags",
  155    155   
    10,
  156    156   
)
  157    157   
.with_xml_name("tagSet");
  158    158   
static IPAMSCOPE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  159    159   
    IPAMSCOPE_SCHEMA_ID,
  160    160   
    ::aws_smithy_schema::ShapeType::Structure,
  161    161   
    &[
  162    162   
        &IPAMSCOPE_MEMBER_OWNER_ID,
  163    163   
        &IPAMSCOPE_MEMBER_IPAM_SCOPE_ID,
  164    164   
        &IPAMSCOPE_MEMBER_IPAM_SCOPE_ARN,
@@ -198,198 +321,329 @@
  218    218   
                    ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  219    219   
                }
  220    220   
                Ok(())
  221    221   
            })?;
  222    222   
        }
  223    223   
        Ok(())
  224    224   
    }
  225    225   
}
  226    226   
impl IpamScope {
  227    227   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  228         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  229         -
        deserializer: &mut D,
         228  +
    pub fn deserialize(
         229  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  230    230   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  231    231   
        #[allow(unused_variables, unused_mut)]
  232    232   
        let mut builder = Self::builder();
  233    233   
        #[allow(
  234    234   
            unused_variables,
  235    235   
            unreachable_code,
  236    236   
            clippy::single_match,
  237    237   
            clippy::match_single_binding,
  238    238   
            clippy::diverging_sub_expression
  239    239   
        )]
  240         -
        deserializer.read_struct(&IPAMSCOPE_SCHEMA, (), |_, member, deser| {
         240  +
        deserializer.read_struct(&IPAMSCOPE_SCHEMA, &mut |member, deser| {
  241    241   
            match member.member_index() {
  242    242   
                Some(0) => {
  243    243   
                    builder.owner_id = Some(deser.read_string(member)?);
  244    244   
                }
  245    245   
                Some(1) => {
  246    246   
                    builder.ipam_scope_id = Some(deser.read_string(member)?);
  247    247   
                }
  248    248   
                Some(2) => {
  249    249   
                    builder.ipam_scope_arn = Some(deser.read_string(member)?);
  250    250   
                }
  251    251   
                Some(3) => {
  252    252   
                    builder.ipam_arn = Some(deser.read_string(member)?);
  253    253   
                }
  254    254   
                Some(4) => {
  255    255   
                    builder.ipam_region = Some(deser.read_string(member)?);
  256    256   
                }
  257    257   
                Some(5) => {
  258    258   
                    builder.ipam_scope_type = Some(crate::types::IpamScopeType::from(deser.read_string(member)?.as_str()));
  259    259   
                }
  260    260   
                Some(6) => {
  261    261   
                    builder.is_default = Some(deser.read_boolean(member)?);
  262    262   
                }
  263    263   
                Some(7) => {
  264    264   
                    builder.description = Some(deser.read_string(member)?);
  265    265   
                }
  266    266   
                Some(8) => {
  267    267   
                    builder.pool_count = Some(deser.read_integer(member)?);
  268    268   
                }
  269    269   
                Some(9) => {
  270    270   
                    builder.state = Some(crate::types::IpamScopeState::from(deser.read_string(member)?.as_str()));
  271    271   
                }
  272    272   
                Some(10) => {
  273    273   
                    builder.tags = Some({
  274         -
                        let container = if let Some(cap) = deser.container_size() {
  275         -
                            Vec::with_capacity(cap)
  276         -
                        } else {
  277         -
                            Vec::new()
  278         -
                        };
  279         -
                        deser.read_list(member, container, |mut list, deser| {
  280         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  281         -
                            Ok(list)
  282         -
                        })?
         274  +
                        let mut container = Vec::new();
         275  +
                        deser.read_list(member, &mut |deser| {
         276  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         277  +
                            Ok(())
         278  +
                        })?;
         279  +
                        container
  283    280   
                    });
  284    281   
                }
  285    282   
                _ => {}
  286    283   
            }
  287    284   
            Ok(())
  288    285   
        })?;
  289    286   
        Ok(builder.build())
  290    287   
    }
  291    288   
}
         289  +
impl IpamScope {
         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  +
}
  292    300   
impl IpamScope {
  293    301   
    /// Creates a new builder-style object to manufacture [`IpamScope`](crate::types::IpamScope).
  294    302   
    pub fn builder() -> crate::types::builders::IpamScopeBuilder {
  295    303   
        crate::types::builders::IpamScopeBuilder::default()
  296    304   
    }
  297    305   
}
  298    306   
  299    307   
/// A builder for [`IpamScope`](crate::types::IpamScope).
  300    308   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  301    309   
#[non_exhaustive]

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

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

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

@@ -1,1 +107,118 @@
   18     18   
    "com.amazonaws.ec2",
   19     19   
    "Ipv4PrefixSpecificationRequest",
   20     20   
);
   21     21   
static IPV4PREFIXSPECIFICATIONREQUEST_MEMBER_IPV4_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.ec2#Ipv4PrefixSpecificationRequest$Ipv4Prefix",
   24     24   
        "com.amazonaws.ec2",
   25     25   
        "Ipv4PrefixSpecificationRequest",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::String,
   28         -
    "ipv4_prefix",
          28  +
    "Ipv4Prefix",
   29     29   
    0,
   30     30   
);
   31     31   
static IPV4PREFIXSPECIFICATIONREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    IPV4PREFIXSPECIFICATIONREQUEST_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&IPV4PREFIXSPECIFICATIONREQUEST_MEMBER_IPV4_PREFIX],
   35     35   
);
   36     36   
impl Ipv4PrefixSpecificationRequest {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IPV4PREFIXSPECIFICATIONREQUEST_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for Ipv4PrefixSpecificationRequest {
   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.ipv4_prefix {
   47     47   
            ser.write_string(&IPV4PREFIXSPECIFICATIONREQUEST_MEMBER_IPV4_PREFIX, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl Ipv4PrefixSpecificationRequest {
   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(&IPV4PREFIXSPECIFICATIONREQUEST_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&IPV4PREFIXSPECIFICATIONREQUEST_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.ipv4_prefix = 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 Ipv4PrefixSpecificationRequest {
          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 Ipv4PrefixSpecificationRequest {
   79     90   
    /// Creates a new builder-style object to manufacture [`Ipv4PrefixSpecificationRequest`](crate::types::Ipv4PrefixSpecificationRequest).
   80     91   
    pub fn builder() -> crate::types::builders::Ipv4PrefixSpecificationRequestBuilder {
   81     92   
        crate::types::builders::Ipv4PrefixSpecificationRequestBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`Ipv4PrefixSpecificationRequest`](crate::types::Ipv4PrefixSpecificationRequest).
   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/_ipv4_prefix_specification_response.rs

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

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

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

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

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

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

@@ -13,13 +200,205 @@
   33     33   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
   34     34   
    pub fn tags(&self) -> &[crate::types::Tag] {
   35     35   
        self.tags.as_deref().unwrap_or_default()
   36     36   
    }
   37     37   
}
   38     38   
static IPV6POOL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   39     39   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Ipv6Pool", "com.amazonaws.ec2", "Ipv6Pool");
   40     40   
static IPV6POOL_MEMBER_POOL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Ipv6Pool$PoolId", "com.amazonaws.ec2", "Ipv6Pool"),
   42     42   
    ::aws_smithy_schema::ShapeType::String,
   43         -
    "pool_id",
          43  +
    "PoolId",
   44     44   
    0,
   45     45   
)
   46     46   
.with_xml_name("poolId");
   47     47   
static IPV6POOL_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   48     48   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Ipv6Pool$Description", "com.amazonaws.ec2", "Ipv6Pool"),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "description",
          50  +
    "Description",
   51     51   
    1,
   52     52   
)
   53     53   
.with_xml_name("description");
   54     54   
static IPV6POOL_MEMBER_POOL_CIDR_BLOCKS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Ipv6Pool$PoolCidrBlocks", "com.amazonaws.ec2", "Ipv6Pool"),
   56     56   
    ::aws_smithy_schema::ShapeType::List,
   57         -
    "pool_cidr_blocks",
          57  +
    "PoolCidrBlocks",
   58     58   
    2,
   59     59   
)
   60     60   
.with_xml_name("poolCidrBlockSet");
   61     61   
static IPV6POOL_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Ipv6Pool$Tags", "com.amazonaws.ec2", "Ipv6Pool"),
   63     63   
    ::aws_smithy_schema::ShapeType::List,
   64         -
    "tags",
          64  +
    "Tags",
   65     65   
    3,
   66     66   
)
   67     67   
.with_xml_name("tagSet");
   68     68   
static IPV6POOL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   69     69   
    IPV6POOL_SCHEMA_ID,
   70     70   
    ::aws_smithy_schema::ShapeType::Structure,
   71     71   
    &[
   72     72   
        &IPV6POOL_MEMBER_POOL_ID,
   73     73   
        &IPV6POOL_MEMBER_DESCRIPTION,
   74     74   
        &IPV6POOL_MEMBER_POOL_CIDR_BLOCKS,
   75     75   
        &IPV6POOL_MEMBER_TAGS,
   76     76   
    ],
   77     77   
);
   78     78   
impl Ipv6Pool {
   79     79   
    /// The schema for this shape.
   80     80   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IPV6POOL_SCHEMA;
   81     81   
}
   82     82   
impl ::aws_smithy_schema::serde::SerializableStruct for Ipv6Pool {
   83     83   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   84     84   
    fn serialize_members(
   85     85   
        &self,
   86     86   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   87     87   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   88     88   
        if let Some(ref val) = self.pool_id {
   89     89   
            ser.write_string(&IPV6POOL_MEMBER_POOL_ID, val)?;
   90     90   
        }
   91     91   
        if let Some(ref val) = self.description {
   92     92   
            ser.write_string(&IPV6POOL_MEMBER_DESCRIPTION, val)?;
   93     93   
        }
   94     94   
        if let Some(ref val) = self.pool_cidr_blocks {
   95     95   
            ser.write_list(
   96     96   
                &IPV6POOL_MEMBER_POOL_CIDR_BLOCKS,
   97     97   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   98     98   
                    for item in val {
   99     99   
                        ser.write_struct(crate::types::PoolCidrBlock::SCHEMA, item)?;
  100    100   
                    }
  101    101   
                    Ok(())
  102    102   
                },
  103    103   
            )?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.tags {
  106    106   
            ser.write_list(&IPV6POOL_MEMBER_TAGS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  107    107   
                for item in val {
  108    108   
                    ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  109    109   
                }
  110    110   
                Ok(())
  111    111   
            })?;
  112    112   
        }
  113    113   
        Ok(())
  114    114   
    }
  115    115   
}
  116    116   
impl Ipv6Pool {
  117    117   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  118         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  119         -
        deserializer: &mut D,
         118  +
    pub fn deserialize(
         119  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  120    120   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  121    121   
        #[allow(unused_variables, unused_mut)]
  122    122   
        let mut builder = Self::builder();
  123    123   
        #[allow(
  124    124   
            unused_variables,
  125    125   
            unreachable_code,
  126    126   
            clippy::single_match,
  127    127   
            clippy::match_single_binding,
  128    128   
            clippy::diverging_sub_expression
  129    129   
        )]
  130         -
        deserializer.read_struct(&IPV6POOL_SCHEMA, (), |_, member, deser| {
         130  +
        deserializer.read_struct(&IPV6POOL_SCHEMA, &mut |member, deser| {
  131    131   
            match member.member_index() {
  132    132   
                Some(0) => {
  133    133   
                    builder.pool_id = Some(deser.read_string(member)?);
  134    134   
                }
  135    135   
                Some(1) => {
  136    136   
                    builder.description = Some(deser.read_string(member)?);
  137    137   
                }
  138    138   
                Some(2) => {
  139    139   
                    builder.pool_cidr_blocks = Some({
  140         -
                        let container = if let Some(cap) = deser.container_size() {
  141         -
                            Vec::with_capacity(cap)
  142         -
                        } else {
  143         -
                            Vec::new()
  144         -
                        };
  145         -
                        deser.read_list(member, container, |mut list, deser| {
  146         -
                            list.push(crate::types::PoolCidrBlock::deserialize(deser)?);
  147         -
                            Ok(list)
  148         -
                        })?
         140  +
                        let mut container = Vec::new();
         141  +
                        deser.read_list(member, &mut |deser| {
         142  +
                            container.push(crate::types::PoolCidrBlock::deserialize(deser)?);
         143  +
                            Ok(())
         144  +
                        })?;
         145  +
                        container
  149    146   
                    });
  150    147   
                }
  151    148   
                Some(3) => {
  152    149   
                    builder.tags = Some({
  153         -
                        let container = if let Some(cap) = deser.container_size() {
  154         -
                            Vec::with_capacity(cap)
  155         -
                        } else {
  156         -
                            Vec::new()
  157         -
                        };
  158         -
                        deser.read_list(member, container, |mut list, deser| {
  159         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  160         -
                            Ok(list)
  161         -
                        })?
         150  +
                        let mut container = Vec::new();
         151  +
                        deser.read_list(member, &mut |deser| {
         152  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         153  +
                            Ok(())
         154  +
                        })?;
         155  +
                        container
  162    156   
                    });
  163    157   
                }
  164    158   
                _ => {}
  165    159   
            }
  166    160   
            Ok(())
  167    161   
        })?;
  168    162   
        Ok(builder.build())
  169    163   
    }
  170    164   
}
         165  +
impl Ipv6Pool {
         166  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         167  +
    pub fn deserialize_with_response(
         168  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         169  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         170  +
        _status: u16,
         171  +
        _body: &[u8],
         172  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         173  +
        Self::deserialize(deserializer)
         174  +
    }
         175  +
}
  171    176   
impl Ipv6Pool {
  172    177   
    /// Creates a new builder-style object to manufacture [`Ipv6Pool`](crate::types::Ipv6Pool).
  173    178   
    pub fn builder() -> crate::types::builders::Ipv6PoolBuilder {
  174    179   
        crate::types::builders::Ipv6PoolBuilder::default()
  175    180   
    }
  176    181   
}
  177    182   
  178    183   
/// A builder for [`Ipv6Pool`](crate::types::Ipv6Pool).
  179    184   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  180    185   
#[non_exhaustive]

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

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

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

@@ -1,1 +107,118 @@
   18     18   
    "com.amazonaws.ec2",
   19     19   
    "Ipv6PrefixSpecificationRequest",
   20     20   
);
   21     21   
static IPV6PREFIXSPECIFICATIONREQUEST_MEMBER_IPV6_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.ec2#Ipv6PrefixSpecificationRequest$Ipv6Prefix",
   24     24   
        "com.amazonaws.ec2",
   25     25   
        "Ipv6PrefixSpecificationRequest",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::String,
   28         -
    "ipv6_prefix",
          28  +
    "Ipv6Prefix",
   29     29   
    0,
   30     30   
);
   31     31   
static IPV6PREFIXSPECIFICATIONREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    IPV6PREFIXSPECIFICATIONREQUEST_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&IPV6PREFIXSPECIFICATIONREQUEST_MEMBER_IPV6_PREFIX],
   35     35   
);
   36     36   
impl Ipv6PrefixSpecificationRequest {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IPV6PREFIXSPECIFICATIONREQUEST_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for Ipv6PrefixSpecificationRequest {
   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_prefix {
   47     47   
            ser.write_string(&IPV6PREFIXSPECIFICATIONREQUEST_MEMBER_IPV6_PREFIX, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl Ipv6PrefixSpecificationRequest {
   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(&IPV6PREFIXSPECIFICATIONREQUEST_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&IPV6PREFIXSPECIFICATIONREQUEST_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.ipv6_prefix = 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 Ipv6PrefixSpecificationRequest {
          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 Ipv6PrefixSpecificationRequest {
   79     90   
    /// Creates a new builder-style object to manufacture [`Ipv6PrefixSpecificationRequest`](crate::types::Ipv6PrefixSpecificationRequest).
   80     91   
    pub fn builder() -> crate::types::builders::Ipv6PrefixSpecificationRequestBuilder {
   81     92   
        crate::types::builders::Ipv6PrefixSpecificationRequestBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`Ipv6PrefixSpecificationRequest`](crate::types::Ipv6PrefixSpecificationRequest).
   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/_ipv6_prefix_specification_response.rs

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

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

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

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

@@ -57,57 +268,276 @@
   77     77   
    /// </ul>
   78     78   
    pub fn key_fingerprint(&self) -> ::std::option::Option<&str> {
   79     79   
        self.key_fingerprint.as_deref()
   80     80   
    }
   81     81   
}
   82     82   
static KEYPAIRINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   83     83   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#KeyPairInfo", "com.amazonaws.ec2", "KeyPairInfo");
   84     84   
static KEYPAIRINFO_MEMBER_KEY_PAIR_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#KeyPairInfo$KeyPairId", "com.amazonaws.ec2", "KeyPairInfo"),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "key_pair_id",
          87  +
    "KeyPairId",
   88     88   
    0,
   89     89   
)
   90     90   
.with_xml_name("keyPairId");
   91     91   
static KEYPAIRINFO_MEMBER_KEY_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#KeyPairInfo$KeyType", "com.amazonaws.ec2", "KeyPairInfo"),
   93     93   
    ::aws_smithy_schema::ShapeType::String,
   94         -
    "key_type",
          94  +
    "KeyType",
   95     95   
    1,
   96     96   
)
   97     97   
.with_xml_name("keyType");
   98     98   
static KEYPAIRINFO_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#KeyPairInfo$Tags", "com.amazonaws.ec2", "KeyPairInfo"),
  100    100   
    ::aws_smithy_schema::ShapeType::List,
  101         -
    "tags",
         101  +
    "Tags",
  102    102   
    2,
  103    103   
)
  104    104   
.with_xml_name("tagSet");
  105    105   
static KEYPAIRINFO_MEMBER_PUBLIC_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#KeyPairInfo$PublicKey", "com.amazonaws.ec2", "KeyPairInfo"),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "public_key",
         108  +
    "PublicKey",
  109    109   
    3,
  110    110   
)
  111    111   
.with_xml_name("publicKey");
  112    112   
static KEYPAIRINFO_MEMBER_CREATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#KeyPairInfo$CreateTime", "com.amazonaws.ec2", "KeyPairInfo"),
  114    114   
    ::aws_smithy_schema::ShapeType::Timestamp,
  115         -
    "create_time",
         115  +
    "CreateTime",
  116    116   
    4,
  117    117   
)
  118    118   
.with_xml_name("createTime");
  119    119   
static KEYPAIRINFO_MEMBER_KEY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#KeyPairInfo$KeyName", "com.amazonaws.ec2", "KeyPairInfo"),
  121    121   
    ::aws_smithy_schema::ShapeType::String,
  122         -
    "key_name",
         122  +
    "KeyName",
  123    123   
    5,
  124    124   
)
  125    125   
.with_xml_name("keyName");
  126    126   
static KEYPAIRINFO_MEMBER_KEY_FINGERPRINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  127    127   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#KeyPairInfo$KeyFingerprint", "com.amazonaws.ec2", "KeyPairInfo"),
  128    128   
    ::aws_smithy_schema::ShapeType::String,
  129         -
    "key_fingerprint",
         129  +
    "KeyFingerprint",
  130    130   
    6,
  131    131   
)
  132    132   
.with_xml_name("keyFingerprint");
  133    133   
static KEYPAIRINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  134    134   
    KEYPAIRINFO_SCHEMA_ID,
  135    135   
    ::aws_smithy_schema::ShapeType::Structure,
  136    136   
    &[
  137    137   
        &KEYPAIRINFO_MEMBER_KEY_PAIR_ID,
  138    138   
        &KEYPAIRINFO_MEMBER_KEY_TYPE,
  139    139   
        &KEYPAIRINFO_MEMBER_TAGS,
  140    140   
        &KEYPAIRINFO_MEMBER_PUBLIC_KEY,
  141    141   
        &KEYPAIRINFO_MEMBER_CREATE_TIME,
  142    142   
        &KEYPAIRINFO_MEMBER_KEY_NAME,
  143    143   
        &KEYPAIRINFO_MEMBER_KEY_FINGERPRINT,
  144    144   
    ],
  145    145   
);
  146    146   
impl KeyPairInfo {
  147    147   
    /// The schema for this shape.
  148    148   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &KEYPAIRINFO_SCHEMA;
  149    149   
}
  150    150   
impl ::aws_smithy_schema::serde::SerializableStruct for KeyPairInfo {
  151    151   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  152    152   
    fn serialize_members(
  153    153   
        &self,
  154    154   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  155    155   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  156    156   
        if let Some(ref val) = self.key_pair_id {
  157    157   
            ser.write_string(&KEYPAIRINFO_MEMBER_KEY_PAIR_ID, val)?;
  158    158   
        }
  159    159   
        if let Some(ref val) = self.key_type {
  160    160   
            ser.write_string(&KEYPAIRINFO_MEMBER_KEY_TYPE, val.as_str())?;
  161    161   
        }
  162    162   
        if let Some(ref val) = self.tags {
  163    163   
            ser.write_list(&KEYPAIRINFO_MEMBER_TAGS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  164    164   
                for item in val {
  165    165   
                    ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  166    166   
                }
  167    167   
                Ok(())
  168    168   
            })?;
  169    169   
        }
  170    170   
        if let Some(ref val) = self.public_key {
  171    171   
            ser.write_string(&KEYPAIRINFO_MEMBER_PUBLIC_KEY, val)?;
  172    172   
        }
  173    173   
        if let Some(ref val) = self.create_time {
  174    174   
            ser.write_timestamp(&KEYPAIRINFO_MEMBER_CREATE_TIME, val)?;
  175    175   
        }
  176    176   
        if let Some(ref val) = self.key_name {
  177    177   
            ser.write_string(&KEYPAIRINFO_MEMBER_KEY_NAME, val)?;
  178    178   
        }
  179    179   
        if let Some(ref val) = self.key_fingerprint {
  180    180   
            ser.write_string(&KEYPAIRINFO_MEMBER_KEY_FINGERPRINT, val)?;
  181    181   
        }
  182    182   
        Ok(())
  183    183   
    }
  184    184   
}
  185    185   
impl KeyPairInfo {
  186    186   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  187         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  188         -
        deserializer: &mut D,
         187  +
    pub fn deserialize(
         188  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  189    189   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  190    190   
        #[allow(unused_variables, unused_mut)]
  191    191   
        let mut builder = Self::builder();
  192    192   
        #[allow(
  193    193   
            unused_variables,
  194    194   
            unreachable_code,
  195    195   
            clippy::single_match,
  196    196   
            clippy::match_single_binding,
  197    197   
            clippy::diverging_sub_expression
  198    198   
        )]
  199         -
        deserializer.read_struct(&KEYPAIRINFO_SCHEMA, (), |_, member, deser| {
         199  +
        deserializer.read_struct(&KEYPAIRINFO_SCHEMA, &mut |member, deser| {
  200    200   
            match member.member_index() {
  201    201   
                Some(0) => {
  202    202   
                    builder.key_pair_id = Some(deser.read_string(member)?);
  203    203   
                }
  204    204   
                Some(1) => {
  205    205   
                    builder.key_type = Some(crate::types::KeyType::from(deser.read_string(member)?.as_str()));
  206    206   
                }
  207    207   
                Some(2) => {
  208    208   
                    builder.tags = Some({
  209         -
                        let container = if let Some(cap) = deser.container_size() {
  210         -
                            Vec::with_capacity(cap)
  211         -
                        } else {
  212         -
                            Vec::new()
  213         -
                        };
  214         -
                        deser.read_list(member, container, |mut list, deser| {
  215         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  216         -
                            Ok(list)
  217         -
                        })?
         209  +
                        let mut container = Vec::new();
         210  +
                        deser.read_list(member, &mut |deser| {
         211  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         212  +
                            Ok(())
         213  +
                        })?;
         214  +
                        container
  218    215   
                    });
  219    216   
                }
  220    217   
                Some(3) => {
  221    218   
                    builder.public_key = Some(deser.read_string(member)?);
  222    219   
                }
  223    220   
                Some(4) => {
  224    221   
                    builder.create_time = Some(deser.read_timestamp(member)?);
  225    222   
                }
  226    223   
                Some(5) => {
  227    224   
                    builder.key_name = Some(deser.read_string(member)?);
  228    225   
                }
  229    226   
                Some(6) => {
  230    227   
                    builder.key_fingerprint = Some(deser.read_string(member)?);
  231    228   
                }
  232    229   
                _ => {}
  233    230   
            }
  234    231   
            Ok(())
  235    232   
        })?;
  236    233   
        Ok(builder.build())
  237    234   
    }
  238    235   
}
         236  +
impl KeyPairInfo {
         237  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         238  +
    pub fn deserialize_with_response(
         239  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         240  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         241  +
        _status: u16,
         242  +
        _body: &[u8],
         243  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         244  +
        Self::deserialize(deserializer)
         245  +
    }
         246  +
}
  239    247   
impl KeyPairInfo {
  240    248   
    /// Creates a new builder-style object to manufacture [`KeyPairInfo`](crate::types::KeyPairInfo).
  241    249   
    pub fn builder() -> crate::types::builders::KeyPairInfoBuilder {
  242    250   
        crate::types::builders::KeyPairInfoBuilder::default()
  243    251   
    }
  244    252   
}
  245    253   
  246    254   
/// A builder for [`KeyPairInfo`](crate::types::KeyPairInfo).
  247    255   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  248    256   
#[non_exhaustive]

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

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

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

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

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

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