AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045

Files changed:

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

@@ -40,40 +149,160 @@
   60     60   
    "com.amazonaws.ec2",
   61     61   
    "AddIpamOrganizationalUnitExclusion",
   62     62   
);
   63     63   
static ADDIPAMORGANIZATIONALUNITEXCLUSION_MEMBER_ORGANIZATIONS_ENTITY_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.ec2#AddIpamOrganizationalUnitExclusion$OrganizationsEntityPath",
   66     66   
        "com.amazonaws.ec2",
   67     67   
        "AddIpamOrganizationalUnitExclusion",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "organizations_entity_path",
          70  +
    "OrganizationsEntityPath",
   71     71   
    0,
   72     72   
);
   73     73   
static ADDIPAMORGANIZATIONALUNITEXCLUSION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   74     74   
    ADDIPAMORGANIZATIONALUNITEXCLUSION_SCHEMA_ID,
   75     75   
    ::aws_smithy_schema::ShapeType::Structure,
   76     76   
    &[&ADDIPAMORGANIZATIONALUNITEXCLUSION_MEMBER_ORGANIZATIONS_ENTITY_PATH],
   77     77   
);
   78     78   
impl AddIpamOrganizationalUnitExclusion {
   79     79   
    /// The schema for this shape.
   80     80   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ADDIPAMORGANIZATIONALUNITEXCLUSION_SCHEMA;
   81     81   
}
   82     82   
impl ::aws_smithy_schema::serde::SerializableStruct for AddIpamOrganizationalUnitExclusion {
   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.organizations_entity_path {
   89     89   
            ser.write_string(&ADDIPAMORGANIZATIONALUNITEXCLUSION_MEMBER_ORGANIZATIONS_ENTITY_PATH, val)?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl AddIpamOrganizationalUnitExclusion {
   95     95   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   96         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   97         -
        deserializer: &mut D,
          96  +
    pub fn deserialize(
          97  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   98     98   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   99     99   
        #[allow(unused_variables, unused_mut)]
  100    100   
        let mut builder = Self::builder();
  101    101   
        #[allow(
  102    102   
            unused_variables,
  103    103   
            unreachable_code,
  104    104   
            clippy::single_match,
  105    105   
            clippy::match_single_binding,
  106    106   
            clippy::diverging_sub_expression
  107    107   
        )]
  108         -
        deserializer.read_struct(&ADDIPAMORGANIZATIONALUNITEXCLUSION_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&ADDIPAMORGANIZATIONALUNITEXCLUSION_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.organizations_entity_path = Some(deser.read_string(member)?);
  112    112   
                }
  113    113   
                _ => {}
  114    114   
            }
  115    115   
            Ok(())
  116    116   
        })?;
  117    117   
        Ok(builder.build())
  118    118   
    }
  119    119   
}
         120  +
impl AddIpamOrganizationalUnitExclusion {
         121  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         122  +
    pub fn deserialize_with_response(
         123  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         124  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         125  +
        _status: u16,
         126  +
        _body: &[u8],
         127  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         128  +
        Self::deserialize(deserializer)
         129  +
    }
         130  +
}
  120    131   
impl AddIpamOrganizationalUnitExclusion {
  121    132   
    /// Creates a new builder-style object to manufacture [`AddIpamOrganizationalUnitExclusion`](crate::types::AddIpamOrganizationalUnitExclusion).
  122    133   
    pub fn builder() -> crate::types::builders::AddIpamOrganizationalUnitExclusionBuilder {
  123    134   
        crate::types::builders::AddIpamOrganizationalUnitExclusionBuilder::default()
  124    135   
    }
  125    136   
}
  126    137   
  127    138   
/// A builder for [`AddIpamOrganizationalUnitExclusion`](crate::types::AddIpamOrganizationalUnitExclusion).
  128    139   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  129    140   
#[non_exhaustive]

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

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

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

@@ -9,9 +167,178 @@
   29     29   
    /// <p>The ID of the service.</p>
   30     30   
    pub fn service_id(&self) -> ::std::option::Option<&str> {
   31     31   
        self.service_id.as_deref()
   32     32   
    }
   33     33   
}
   34     34   
static ADDEDPRINCIPAL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   35     35   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AddedPrincipal", "com.amazonaws.ec2", "AddedPrincipal");
   36     36   
static ADDEDPRINCIPAL_MEMBER_PRINCIPAL_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AddedPrincipal$PrincipalType", "com.amazonaws.ec2", "AddedPrincipal"),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "principal_type",
          39  +
    "PrincipalType",
   40     40   
    0,
   41     41   
)
   42     42   
.with_xml_name("principalType");
   43     43   
static ADDEDPRINCIPAL_MEMBER_PRINCIPAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AddedPrincipal$Principal", "com.amazonaws.ec2", "AddedPrincipal"),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "principal",
          46  +
    "Principal",
   47     47   
    1,
   48     48   
)
   49     49   
.with_xml_name("principal");
   50     50   
static ADDEDPRINCIPAL_MEMBER_SERVICE_PERMISSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.ec2#AddedPrincipal$ServicePermissionId",
   53     53   
        "com.amazonaws.ec2",
   54     54   
        "AddedPrincipal",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "service_permission_id",
          57  +
    "ServicePermissionId",
   58     58   
    2,
   59     59   
)
   60     60   
.with_xml_name("servicePermissionId");
   61     61   
static ADDEDPRINCIPAL_MEMBER_SERVICE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AddedPrincipal$ServiceId", "com.amazonaws.ec2", "AddedPrincipal"),
   63     63   
    ::aws_smithy_schema::ShapeType::String,
   64         -
    "service_id",
          64  +
    "ServiceId",
   65     65   
    3,
   66     66   
)
   67     67   
.with_xml_name("serviceId");
   68     68   
static ADDEDPRINCIPAL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   69     69   
    ADDEDPRINCIPAL_SCHEMA_ID,
   70     70   
    ::aws_smithy_schema::ShapeType::Structure,
   71     71   
    &[
   72     72   
        &ADDEDPRINCIPAL_MEMBER_PRINCIPAL_TYPE,
   73     73   
        &ADDEDPRINCIPAL_MEMBER_PRINCIPAL,
   74     74   
        &ADDEDPRINCIPAL_MEMBER_SERVICE_PERMISSION_ID,
   75     75   
        &ADDEDPRINCIPAL_MEMBER_SERVICE_ID,
   76     76   
    ],
   77     77   
);
   78     78   
impl AddedPrincipal {
   79     79   
    /// The schema for this shape.
   80     80   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ADDEDPRINCIPAL_SCHEMA;
   81     81   
}
   82     82   
impl ::aws_smithy_schema::serde::SerializableStruct for AddedPrincipal {
   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.principal_type {
   89     89   
            ser.write_string(&ADDEDPRINCIPAL_MEMBER_PRINCIPAL_TYPE, val.as_str())?;
   90     90   
        }
   91     91   
        if let Some(ref val) = self.principal {
   92     92   
            ser.write_string(&ADDEDPRINCIPAL_MEMBER_PRINCIPAL, val)?;
   93     93   
        }
   94     94   
        if let Some(ref val) = self.service_permission_id {
   95     95   
            ser.write_string(&ADDEDPRINCIPAL_MEMBER_SERVICE_PERMISSION_ID, val)?;
   96     96   
        }
   97     97   
        if let Some(ref val) = self.service_id {
   98     98   
            ser.write_string(&ADDEDPRINCIPAL_MEMBER_SERVICE_ID, val)?;
   99     99   
        }
  100    100   
        Ok(())
  101    101   
    }
  102    102   
}
  103    103   
impl AddedPrincipal {
  104    104   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  105         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  106         -
        deserializer: &mut D,
         105  +
    pub fn deserialize(
         106  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  107    107   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  108    108   
        #[allow(unused_variables, unused_mut)]
  109    109   
        let mut builder = Self::builder();
  110    110   
        #[allow(
  111    111   
            unused_variables,
  112    112   
            unreachable_code,
  113    113   
            clippy::single_match,
  114    114   
            clippy::match_single_binding,
  115    115   
            clippy::diverging_sub_expression
  116    116   
        )]
  117         -
        deserializer.read_struct(&ADDEDPRINCIPAL_SCHEMA, (), |_, member, deser| {
         117  +
        deserializer.read_struct(&ADDEDPRINCIPAL_SCHEMA, &mut |member, deser| {
  118    118   
            match member.member_index() {
  119    119   
                Some(0) => {
  120    120   
                    builder.principal_type = Some(crate::types::PrincipalType::from(deser.read_string(member)?.as_str()));
  121    121   
                }
  122    122   
                Some(1) => {
  123    123   
                    builder.principal = Some(deser.read_string(member)?);
  124    124   
                }
  125    125   
                Some(2) => {
  126    126   
                    builder.service_permission_id = Some(deser.read_string(member)?);
  127    127   
                }
  128    128   
                Some(3) => {
  129    129   
                    builder.service_id = Some(deser.read_string(member)?);
  130    130   
                }
  131    131   
                _ => {}
  132    132   
            }
  133    133   
            Ok(())
  134    134   
        })?;
  135    135   
        Ok(builder.build())
  136    136   
    }
  137    137   
}
         138  +
impl AddedPrincipal {
         139  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         140  +
    pub fn deserialize_with_response(
         141  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         142  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         143  +
        _status: u16,
         144  +
        _body: &[u8],
         145  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         146  +
        Self::deserialize(deserializer)
         147  +
    }
         148  +
}
  138    149   
impl AddedPrincipal {
  139    150   
    /// Creates a new builder-style object to manufacture [`AddedPrincipal`](crate::types::AddedPrincipal).
  140    151   
    pub fn builder() -> crate::types::builders::AddedPrincipalBuilder {
  141    152   
        crate::types::builders::AddedPrincipalBuilder::default()
  142    153   
    }
  143    154   
}
  144    155   
  145    156   
/// A builder for [`AddedPrincipal`](crate::types::AddedPrincipal).
  146    157   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  147    158   
#[non_exhaustive]

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

@@ -45,45 +170,170 @@
   65     65   
}
   66     66   
static ADDITIONALDETAIL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AdditionalDetail", "com.amazonaws.ec2", "AdditionalDetail");
   68     68   
static ADDITIONALDETAIL_MEMBER_ADDITIONAL_DETAIL_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.ec2#AdditionalDetail$AdditionalDetailType",
   71     71   
        "com.amazonaws.ec2",
   72     72   
        "AdditionalDetail",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "additional_detail_type",
          75  +
    "AdditionalDetailType",
   76     76   
    0,
   77     77   
)
   78     78   
.with_xml_name("additionalDetailType");
   79     79   
static ADDITIONALDETAIL_MEMBER_COMPONENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AdditionalDetail$Component", "com.amazonaws.ec2", "AdditionalDetail"),
   81     81   
    ::aws_smithy_schema::ShapeType::Structure,
   82         -
    "component",
          82  +
    "Component",
   83     83   
    1,
   84     84   
)
   85     85   
.with_xml_name("component");
   86     86   
static ADDITIONALDETAIL_MEMBER_VPC_ENDPOINT_SERVICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.ec2#AdditionalDetail$VpcEndpointService",
   89     89   
        "com.amazonaws.ec2",
   90     90   
        "AdditionalDetail",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::Structure,
   93         -
    "vpc_endpoint_service",
          93  +
    "VpcEndpointService",
   94     94   
    2,
   95     95   
)
   96     96   
.with_xml_name("vpcEndpointService");
   97     97   
static ADDITIONALDETAIL_MEMBER_RULE_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AdditionalDetail$RuleOptions", "com.amazonaws.ec2", "AdditionalDetail"),
   99     99   
    ::aws_smithy_schema::ShapeType::List,
  100         -
    "rule_options",
         100  +
    "RuleOptions",
  101    101   
    3,
  102    102   
)
  103    103   
.with_xml_name("ruleOptionSet");
  104    104   
static ADDITIONALDETAIL_MEMBER_RULE_GROUP_TYPE_PAIRS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static(
  106    106   
        "com.amazonaws.ec2#AdditionalDetail$RuleGroupTypePairs",
  107    107   
        "com.amazonaws.ec2",
  108    108   
        "AdditionalDetail",
  109    109   
    ),
  110    110   
    ::aws_smithy_schema::ShapeType::List,
  111         -
    "rule_group_type_pairs",
         111  +
    "RuleGroupTypePairs",
  112    112   
    4,
  113    113   
)
  114    114   
.with_xml_name("ruleGroupTypePairSet");
  115    115   
static ADDITIONALDETAIL_MEMBER_RULE_GROUP_RULE_OPTIONS_PAIRS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static(
  117    117   
        "com.amazonaws.ec2#AdditionalDetail$RuleGroupRuleOptionsPairs",
  118    118   
        "com.amazonaws.ec2",
  119    119   
        "AdditionalDetail",
  120    120   
    ),
  121    121   
    ::aws_smithy_schema::ShapeType::List,
  122         -
    "rule_group_rule_options_pairs",
         122  +
    "RuleGroupRuleOptionsPairs",
  123    123   
    5,
  124    124   
)
  125    125   
.with_xml_name("ruleGroupRuleOptionsPairSet");
  126    126   
static ADDITIONALDETAIL_MEMBER_SERVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  127    127   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AdditionalDetail$ServiceName", "com.amazonaws.ec2", "AdditionalDetail"),
  128    128   
    ::aws_smithy_schema::ShapeType::String,
  129         -
    "service_name",
         129  +
    "ServiceName",
  130    130   
    6,
  131    131   
)
  132    132   
.with_xml_name("serviceName");
  133    133   
static ADDITIONALDETAIL_MEMBER_LOAD_BALANCERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  134    134   
    ::aws_smithy_schema::ShapeId::from_static(
  135    135   
        "com.amazonaws.ec2#AdditionalDetail$LoadBalancers",
  136    136   
        "com.amazonaws.ec2",
  137    137   
        "AdditionalDetail",
  138    138   
    ),
  139    139   
    ::aws_smithy_schema::ShapeType::List,
  140         -
    "load_balancers",
         140  +
    "LoadBalancers",
  141    141   
    7,
  142    142   
)
  143    143   
.with_xml_name("loadBalancerSet");
  144    144   
static ADDITIONALDETAIL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  145    145   
    ADDITIONALDETAIL_SCHEMA_ID,
  146    146   
    ::aws_smithy_schema::ShapeType::Structure,
  147    147   
    &[
  148    148   
        &ADDITIONALDETAIL_MEMBER_ADDITIONAL_DETAIL_TYPE,
  149    149   
        &ADDITIONALDETAIL_MEMBER_COMPONENT,
  150    150   
        &ADDITIONALDETAIL_MEMBER_VPC_ENDPOINT_SERVICE,
@@ -199,199 +343,342 @@
  219    219   
                    }
  220    220   
                    Ok(())
  221    221   
                },
  222    222   
            )?;
  223    223   
        }
  224    224   
        Ok(())
  225    225   
    }
  226    226   
}
  227    227   
impl AdditionalDetail {
  228    228   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  229         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  230         -
        deserializer: &mut D,
         229  +
    pub fn deserialize(
         230  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  231    231   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  232    232   
        #[allow(unused_variables, unused_mut)]
  233    233   
        let mut builder = Self::builder();
  234    234   
        #[allow(
  235    235   
            unused_variables,
  236    236   
            unreachable_code,
  237    237   
            clippy::single_match,
  238    238   
            clippy::match_single_binding,
  239    239   
            clippy::diverging_sub_expression
  240    240   
        )]
  241         -
        deserializer.read_struct(&ADDITIONALDETAIL_SCHEMA, (), |_, member, deser| {
         241  +
        deserializer.read_struct(&ADDITIONALDETAIL_SCHEMA, &mut |member, deser| {
  242    242   
            match member.member_index() {
  243    243   
                Some(0) => {
  244    244   
                    builder.additional_detail_type = Some(deser.read_string(member)?);
  245    245   
                }
  246    246   
                Some(1) => {
  247    247   
                    builder.component = Some(crate::types::AnalysisComponent::deserialize(deser)?);
  248    248   
                }
  249    249   
                Some(2) => {
  250    250   
                    builder.vpc_endpoint_service = Some(crate::types::AnalysisComponent::deserialize(deser)?);
  251    251   
                }
  252    252   
                Some(3) => {
  253    253   
                    builder.rule_options = Some({
  254         -
                        let container = if let Some(cap) = deser.container_size() {
  255         -
                            Vec::with_capacity(cap)
  256         -
                        } else {
  257         -
                            Vec::new()
  258         -
                        };
  259         -
                        deser.read_list(member, container, |mut list, deser| {
  260         -
                            list.push(crate::types::RuleOption::deserialize(deser)?);
  261         -
                            Ok(list)
  262         -
                        })?
         254  +
                        let mut container = Vec::new();
         255  +
                        deser.read_list(member, &mut |deser| {
         256  +
                            container.push(crate::types::RuleOption::deserialize(deser)?);
         257  +
                            Ok(())
         258  +
                        })?;
         259  +
                        container
  263    260   
                    });
  264    261   
                }
  265    262   
                Some(4) => {
  266    263   
                    builder.rule_group_type_pairs = Some({
  267         -
                        let container = if let Some(cap) = deser.container_size() {
  268         -
                            Vec::with_capacity(cap)
  269         -
                        } else {
  270         -
                            Vec::new()
  271         -
                        };
  272         -
                        deser.read_list(member, container, |mut list, deser| {
  273         -
                            list.push(crate::types::RuleGroupTypePair::deserialize(deser)?);
  274         -
                            Ok(list)
  275         -
                        })?
         264  +
                        let mut container = Vec::new();
         265  +
                        deser.read_list(member, &mut |deser| {
         266  +
                            container.push(crate::types::RuleGroupTypePair::deserialize(deser)?);
         267  +
                            Ok(())
         268  +
                        })?;
         269  +
                        container
  276    270   
                    });
  277    271   
                }
  278    272   
                Some(5) => {
  279    273   
                    builder.rule_group_rule_options_pairs = Some({
  280         -
                        let container = if let Some(cap) = deser.container_size() {
  281         -
                            Vec::with_capacity(cap)
  282         -
                        } else {
  283         -
                            Vec::new()
  284         -
                        };
  285         -
                        deser.read_list(member, container, |mut list, deser| {
  286         -
                            list.push(crate::types::RuleGroupRuleOptionsPair::deserialize(deser)?);
  287         -
                            Ok(list)
  288         -
                        })?
         274  +
                        let mut container = Vec::new();
         275  +
                        deser.read_list(member, &mut |deser| {
         276  +
                            container.push(crate::types::RuleGroupRuleOptionsPair::deserialize(deser)?);
         277  +
                            Ok(())
         278  +
                        })?;
         279  +
                        container
  289    280   
                    });
  290    281   
                }
  291    282   
                Some(6) => {
  292    283   
                    builder.service_name = Some(deser.read_string(member)?);
  293    284   
                }
  294    285   
                Some(7) => {
  295    286   
                    builder.load_balancers = Some({
  296         -
                        let container = if let Some(cap) = deser.container_size() {
  297         -
                            Vec::with_capacity(cap)
  298         -
                        } else {
  299         -
                            Vec::new()
  300         -
                        };
  301         -
                        deser.read_list(member, container, |mut list, deser| {
  302         -
                            list.push(crate::types::AnalysisComponent::deserialize(deser)?);
  303         -
                            Ok(list)
  304         -
                        })?
         287  +
                        let mut container = Vec::new();
         288  +
                        deser.read_list(member, &mut |deser| {
         289  +
                            container.push(crate::types::AnalysisComponent::deserialize(deser)?);
         290  +
                            Ok(())
         291  +
                        })?;
         292  +
                        container
  305    293   
                    });
  306    294   
                }
  307    295   
                _ => {}
  308    296   
            }
  309    297   
            Ok(())
  310    298   
        })?;
  311    299   
        Ok(builder.build())
  312    300   
    }
  313    301   
}
         302  +
impl AdditionalDetail {
         303  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         304  +
    pub fn deserialize_with_response(
         305  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         306  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         307  +
        _status: u16,
         308  +
        _body: &[u8],
         309  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         310  +
        Self::deserialize(deserializer)
         311  +
    }
         312  +
}
  314    313   
impl AdditionalDetail {
  315    314   
    /// Creates a new builder-style object to manufacture [`AdditionalDetail`](crate::types::AdditionalDetail).
  316    315   
    pub fn builder() -> crate::types::builders::AdditionalDetailBuilder {
  317    316   
        crate::types::builders::AdditionalDetailBuilder::default()
  318    317   
    }
  319    318   
}
  320    319   
  321    320   
/// A builder for [`AdditionalDetail`](crate::types::AdditionalDetail).
  322    321   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  323    322   
#[non_exhaustive]

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

@@ -87,87 +252,252 @@
  107    107   
    /// <p>The Elastic IP address.</p>
  108    108   
    pub fn public_ip(&self) -> ::std::option::Option<&str> {
  109    109   
        self.public_ip.as_deref()
  110    110   
    }
  111    111   
}
  112    112   
static ADDRESS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  113    113   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address", "com.amazonaws.ec2", "Address");
  114    114   
static ADDRESS_MEMBER_ALLOCATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$AllocationId", "com.amazonaws.ec2", "Address"),
  116    116   
    ::aws_smithy_schema::ShapeType::String,
  117         -
    "allocation_id",
         117  +
    "AllocationId",
  118    118   
    0,
  119    119   
)
  120    120   
.with_xml_name("allocationId");
  121    121   
static ADDRESS_MEMBER_ASSOCIATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$AssociationId", "com.amazonaws.ec2", "Address"),
  123    123   
    ::aws_smithy_schema::ShapeType::String,
  124         -
    "association_id",
         124  +
    "AssociationId",
  125    125   
    1,
  126    126   
)
  127    127   
.with_xml_name("associationId");
  128    128   
static ADDRESS_MEMBER_DOMAIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$Domain", "com.amazonaws.ec2", "Address"),
  130    130   
    ::aws_smithy_schema::ShapeType::String,
  131         -
    "domain",
         131  +
    "Domain",
  132    132   
    2,
  133    133   
)
  134    134   
.with_xml_name("domain");
  135    135   
static ADDRESS_MEMBER_NETWORK_INTERFACE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$NetworkInterfaceId", "com.amazonaws.ec2", "Address"),
  137    137   
    ::aws_smithy_schema::ShapeType::String,
  138         -
    "network_interface_id",
         138  +
    "NetworkInterfaceId",
  139    139   
    3,
  140    140   
)
  141    141   
.with_xml_name("networkInterfaceId");
  142    142   
static ADDRESS_MEMBER_NETWORK_INTERFACE_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  143    143   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$NetworkInterfaceOwnerId", "com.amazonaws.ec2", "Address"),
  144    144   
    ::aws_smithy_schema::ShapeType::String,
  145         -
    "network_interface_owner_id",
         145  +
    "NetworkInterfaceOwnerId",
  146    146   
    4,
  147    147   
)
  148    148   
.with_xml_name("networkInterfaceOwnerId");
  149    149   
static ADDRESS_MEMBER_PRIVATE_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$PrivateIpAddress", "com.amazonaws.ec2", "Address"),
  151    151   
    ::aws_smithy_schema::ShapeType::String,
  152         -
    "private_ip_address",
         152  +
    "PrivateIpAddress",
  153    153   
    5,
  154    154   
)
  155    155   
.with_xml_name("privateIpAddress");
  156    156   
static ADDRESS_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  157    157   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$Tags", "com.amazonaws.ec2", "Address"),
  158    158   
    ::aws_smithy_schema::ShapeType::List,
  159         -
    "tags",
         159  +
    "Tags",
  160    160   
    6,
  161    161   
)
  162    162   
.with_xml_name("tagSet");
  163    163   
static ADDRESS_MEMBER_PUBLIC_IPV4_POOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  164    164   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$PublicIpv4Pool", "com.amazonaws.ec2", "Address"),
  165    165   
    ::aws_smithy_schema::ShapeType::String,
  166         -
    "public_ipv4_pool",
         166  +
    "PublicIpv4Pool",
  167    167   
    7,
  168    168   
)
  169    169   
.with_xml_name("publicIpv4Pool");
  170    170   
static ADDRESS_MEMBER_NETWORK_BORDER_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  171    171   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$NetworkBorderGroup", "com.amazonaws.ec2", "Address"),
  172    172   
    ::aws_smithy_schema::ShapeType::String,
  173         -
    "network_border_group",
         173  +
    "NetworkBorderGroup",
  174    174   
    8,
  175    175   
)
  176    176   
.with_xml_name("networkBorderGroup");
  177    177   
static ADDRESS_MEMBER_CUSTOMER_OWNED_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  178    178   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$CustomerOwnedIp", "com.amazonaws.ec2", "Address"),
  179    179   
    ::aws_smithy_schema::ShapeType::String,
  180         -
    "customer_owned_ip",
         180  +
    "CustomerOwnedIp",
  181    181   
    9,
  182    182   
)
  183    183   
.with_xml_name("customerOwnedIp");
  184    184   
static ADDRESS_MEMBER_CUSTOMER_OWNED_IPV4_POOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  185    185   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$CustomerOwnedIpv4Pool", "com.amazonaws.ec2", "Address"),
  186    186   
    ::aws_smithy_schema::ShapeType::String,
  187         -
    "customer_owned_ipv4_pool",
         187  +
    "CustomerOwnedIpv4Pool",
  188    188   
    10,
  189    189   
)
  190    190   
.with_xml_name("customerOwnedIpv4Pool");
  191    191   
static ADDRESS_MEMBER_CARRIER_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  192    192   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$CarrierIp", "com.amazonaws.ec2", "Address"),
  193    193   
    ::aws_smithy_schema::ShapeType::String,
  194         -
    "carrier_ip",
         194  +
    "CarrierIp",
  195    195   
    11,
  196    196   
)
  197    197   
.with_xml_name("carrierIp");
  198    198   
static ADDRESS_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  199    199   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$SubnetId", "com.amazonaws.ec2", "Address"),
  200    200   
    ::aws_smithy_schema::ShapeType::String,
  201         -
    "subnet_id",
         201  +
    "SubnetId",
  202    202   
    12,
  203    203   
)
  204    204   
.with_xml_name("subnetId");
  205    205   
static ADDRESS_MEMBER_SERVICE_MANAGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  206    206   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$ServiceManaged", "com.amazonaws.ec2", "Address"),
  207    207   
    ::aws_smithy_schema::ShapeType::String,
  208         -
    "service_managed",
         208  +
    "ServiceManaged",
  209    209   
    13,
  210    210   
)
  211    211   
.with_xml_name("serviceManaged");
  212    212   
static ADDRESS_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  213    213   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$InstanceId", "com.amazonaws.ec2", "Address"),
  214    214   
    ::aws_smithy_schema::ShapeType::String,
  215         -
    "instance_id",
         215  +
    "InstanceId",
  216    216   
    14,
  217    217   
)
  218    218   
.with_xml_name("instanceId");
  219    219   
static ADDRESS_MEMBER_PUBLIC_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  220    220   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Address$PublicIp", "com.amazonaws.ec2", "Address"),
  221    221   
    ::aws_smithy_schema::ShapeType::String,
  222         -
    "public_ip",
         222  +
    "PublicIp",
  223    223   
    15,
  224    224   
)
  225    225   
.with_xml_name("publicIp");
  226    226   
static ADDRESS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  227    227   
    ADDRESS_SCHEMA_ID,
  228    228   
    ::aws_smithy_schema::ShapeType::Structure,
  229    229   
    &[
  230    230   
        &ADDRESS_MEMBER_ALLOCATION_ID,
  231    231   
        &ADDRESS_MEMBER_ASSOCIATION_ID,
  232    232   
        &ADDRESS_MEMBER_DOMAIN,
@@ -286,286 +424,432 @@
  306    306   
            ser.write_string(&ADDRESS_MEMBER_INSTANCE_ID, val)?;
  307    307   
        }
  308    308   
        if let Some(ref val) = self.public_ip {
  309    309   
            ser.write_string(&ADDRESS_MEMBER_PUBLIC_IP, val)?;
  310    310   
        }
  311    311   
        Ok(())
  312    312   
    }
  313    313   
}
  314    314   
impl Address {
  315    315   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  316         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  317         -
        deserializer: &mut D,
         316  +
    pub fn deserialize(
         317  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  318    318   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  319    319   
        #[allow(unused_variables, unused_mut)]
  320    320   
        let mut builder = Self::builder();
  321    321   
        #[allow(
  322    322   
            unused_variables,
  323    323   
            unreachable_code,
  324    324   
            clippy::single_match,
  325    325   
            clippy::match_single_binding,
  326    326   
            clippy::diverging_sub_expression
  327    327   
        )]
  328         -
        deserializer.read_struct(&ADDRESS_SCHEMA, (), |_, member, deser| {
         328  +
        deserializer.read_struct(&ADDRESS_SCHEMA, &mut |member, deser| {
  329    329   
            match member.member_index() {
  330    330   
                Some(0) => {
  331    331   
                    builder.allocation_id = Some(deser.read_string(member)?);
  332    332   
                }
  333    333   
                Some(1) => {
  334    334   
                    builder.association_id = Some(deser.read_string(member)?);
  335    335   
                }
  336    336   
                Some(2) => {
  337    337   
                    builder.domain = Some(crate::types::DomainType::from(deser.read_string(member)?.as_str()));
  338    338   
                }
  339    339   
                Some(3) => {
  340    340   
                    builder.network_interface_id = Some(deser.read_string(member)?);
  341    341   
                }
  342    342   
                Some(4) => {
  343    343   
                    builder.network_interface_owner_id = Some(deser.read_string(member)?);
  344    344   
                }
  345    345   
                Some(5) => {
  346    346   
                    builder.private_ip_address = Some(deser.read_string(member)?);
  347    347   
                }
  348    348   
                Some(6) => {
  349    349   
                    builder.tags = Some({
  350         -
                        let container = if let Some(cap) = deser.container_size() {
  351         -
                            Vec::with_capacity(cap)
  352         -
                        } else {
  353         -
                            Vec::new()
  354         -
                        };
  355         -
                        deser.read_list(member, container, |mut list, deser| {
  356         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  357         -
                            Ok(list)
  358         -
                        })?
         350  +
                        let mut container = Vec::new();
         351  +
                        deser.read_list(member, &mut |deser| {
         352  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         353  +
                            Ok(())
         354  +
                        })?;
         355  +
                        container
  359    356   
                    });
  360    357   
                }
  361    358   
                Some(7) => {
  362    359   
                    builder.public_ipv4_pool = Some(deser.read_string(member)?);
  363    360   
                }
  364    361   
                Some(8) => {
  365    362   
                    builder.network_border_group = Some(deser.read_string(member)?);
  366    363   
                }
  367    364   
                Some(9) => {
  368    365   
                    builder.customer_owned_ip = Some(deser.read_string(member)?);
  369    366   
                }
  370    367   
                Some(10) => {
  371    368   
                    builder.customer_owned_ipv4_pool = Some(deser.read_string(member)?);
  372    369   
                }
  373    370   
                Some(11) => {
  374    371   
                    builder.carrier_ip = Some(deser.read_string(member)?);
  375    372   
                }
  376    373   
                Some(12) => {
  377    374   
                    builder.subnet_id = Some(deser.read_string(member)?);
  378    375   
                }
  379    376   
                Some(13) => {
  380    377   
                    builder.service_managed = Some(crate::types::ServiceManaged::from(deser.read_string(member)?.as_str()));
  381    378   
                }
  382    379   
                Some(14) => {
  383    380   
                    builder.instance_id = Some(deser.read_string(member)?);
  384    381   
                }
  385    382   
                Some(15) => {
  386    383   
                    builder.public_ip = Some(deser.read_string(member)?);
  387    384   
                }
  388    385   
                _ => {}
  389    386   
            }
  390    387   
            Ok(())
  391    388   
        })?;
  392    389   
        Ok(builder.build())
  393    390   
    }
  394    391   
}
         392  +
impl Address {
         393  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         394  +
    pub fn deserialize_with_response(
         395  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         396  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         397  +
        _status: u16,
         398  +
        _body: &[u8],
         399  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         400  +
        Self::deserialize(deserializer)
         401  +
    }
         402  +
}
  395    403   
impl Address {
  396    404   
    /// Creates a new builder-style object to manufacture [`Address`](crate::types::Address).
  397    405   
    pub fn builder() -> crate::types::builders::AddressBuilder {
  398    406   
        crate::types::builders::AddressBuilder::default()
  399    407   
    }
  400    408   
}
  401    409   
  402    410   
/// A builder for [`Address`](crate::types::Address).
  403    411   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  404    412   
#[non_exhaustive]

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

@@ -9,9 +167,178 @@
   29     29   
    /// <p>The updated PTR record for the IP address.</p>
   30     30   
    pub fn ptr_record_update(&self) -> ::std::option::Option<&crate::types::PtrUpdateStatus> {
   31     31   
        self.ptr_record_update.as_ref()
   32     32   
    }
   33     33   
}
   34     34   
static ADDRESSATTRIBUTE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   35     35   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AddressAttribute", "com.amazonaws.ec2", "AddressAttribute");
   36     36   
static ADDRESSATTRIBUTE_MEMBER_PUBLIC_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AddressAttribute$PublicIp", "com.amazonaws.ec2", "AddressAttribute"),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "public_ip",
          39  +
    "PublicIp",
   40     40   
    0,
   41     41   
)
   42     42   
.with_xml_name("publicIp");
   43     43   
static ADDRESSATTRIBUTE_MEMBER_ALLOCATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AddressAttribute$AllocationId", "com.amazonaws.ec2", "AddressAttribute"),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "allocation_id",
          46  +
    "AllocationId",
   47     47   
    1,
   48     48   
)
   49     49   
.with_xml_name("allocationId");
   50     50   
static ADDRESSATTRIBUTE_MEMBER_PTR_RECORD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AddressAttribute$PtrRecord", "com.amazonaws.ec2", "AddressAttribute"),
   52     52   
    ::aws_smithy_schema::ShapeType::String,
   53         -
    "ptr_record",
          53  +
    "PtrRecord",
   54     54   
    2,
   55     55   
)
   56     56   
.with_xml_name("ptrRecord");
   57     57   
static ADDRESSATTRIBUTE_MEMBER_PTR_RECORD_UPDATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.ec2#AddressAttribute$PtrRecordUpdate",
   60     60   
        "com.amazonaws.ec2",
   61     61   
        "AddressAttribute",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::Structure,
   64         -
    "ptr_record_update",
          64  +
    "PtrRecordUpdate",
   65     65   
    3,
   66     66   
)
   67     67   
.with_xml_name("ptrRecordUpdate");
   68     68   
static ADDRESSATTRIBUTE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   69     69   
    ADDRESSATTRIBUTE_SCHEMA_ID,
   70     70   
    ::aws_smithy_schema::ShapeType::Structure,
   71     71   
    &[
   72     72   
        &ADDRESSATTRIBUTE_MEMBER_PUBLIC_IP,
   73     73   
        &ADDRESSATTRIBUTE_MEMBER_ALLOCATION_ID,
   74     74   
        &ADDRESSATTRIBUTE_MEMBER_PTR_RECORD,
   75     75   
        &ADDRESSATTRIBUTE_MEMBER_PTR_RECORD_UPDATE,
   76     76   
    ],
   77     77   
);
   78     78   
impl AddressAttribute {
   79     79   
    /// The schema for this shape.
   80     80   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ADDRESSATTRIBUTE_SCHEMA;
   81     81   
}
   82     82   
impl ::aws_smithy_schema::serde::SerializableStruct for AddressAttribute {
   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.public_ip {
   89     89   
            ser.write_string(&ADDRESSATTRIBUTE_MEMBER_PUBLIC_IP, val)?;
   90     90   
        }
   91     91   
        if let Some(ref val) = self.allocation_id {
   92     92   
            ser.write_string(&ADDRESSATTRIBUTE_MEMBER_ALLOCATION_ID, val)?;
   93     93   
        }
   94     94   
        if let Some(ref val) = self.ptr_record {
   95     95   
            ser.write_string(&ADDRESSATTRIBUTE_MEMBER_PTR_RECORD, val)?;
   96     96   
        }
   97     97   
        if let Some(ref val) = self.ptr_record_update {
   98     98   
            ser.write_struct(&ADDRESSATTRIBUTE_MEMBER_PTR_RECORD_UPDATE, val)?;
   99     99   
        }
  100    100   
        Ok(())
  101    101   
    }
  102    102   
}
  103    103   
impl AddressAttribute {
  104    104   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  105         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  106         -
        deserializer: &mut D,
         105  +
    pub fn deserialize(
         106  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  107    107   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  108    108   
        #[allow(unused_variables, unused_mut)]
  109    109   
        let mut builder = Self::builder();
  110    110   
        #[allow(
  111    111   
            unused_variables,
  112    112   
            unreachable_code,
  113    113   
            clippy::single_match,
  114    114   
            clippy::match_single_binding,
  115    115   
            clippy::diverging_sub_expression
  116    116   
        )]
  117         -
        deserializer.read_struct(&ADDRESSATTRIBUTE_SCHEMA, (), |_, member, deser| {
         117  +
        deserializer.read_struct(&ADDRESSATTRIBUTE_SCHEMA, &mut |member, deser| {
  118    118   
            match member.member_index() {
  119    119   
                Some(0) => {
  120    120   
                    builder.public_ip = Some(deser.read_string(member)?);
  121    121   
                }
  122    122   
                Some(1) => {
  123    123   
                    builder.allocation_id = Some(deser.read_string(member)?);
  124    124   
                }
  125    125   
                Some(2) => {
  126    126   
                    builder.ptr_record = Some(deser.read_string(member)?);
  127    127   
                }
  128    128   
                Some(3) => {
  129    129   
                    builder.ptr_record_update = Some(crate::types::PtrUpdateStatus::deserialize(deser)?);
  130    130   
                }
  131    131   
                _ => {}
  132    132   
            }
  133    133   
            Ok(())
  134    134   
        })?;
  135    135   
        Ok(builder.build())
  136    136   
    }
  137    137   
}
         138  +
impl AddressAttribute {
         139  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         140  +
    pub fn deserialize_with_response(
         141  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         142  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         143  +
        _status: u16,
         144  +
        _body: &[u8],
         145  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         146  +
        Self::deserialize(deserializer)
         147  +
    }
         148  +
}
  138    149   
impl AddressAttribute {
  139    150   
    /// Creates a new builder-style object to manufacture [`AddressAttribute`](crate::types::AddressAttribute).
  140    151   
    pub fn builder() -> crate::types::builders::AddressAttributeBuilder {
  141    152   
        crate::types::builders::AddressAttributeBuilder::default()
  142    153   
    }
  143    154   
}
  144    155   
  145    156   
/// A builder for [`AddressAttribute`](crate::types::AddressAttribute).
  146    157   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  147    158   
#[non_exhaustive]

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

@@ -21,21 +219,230 @@
   41     41   
    /// <p>The Elastic IP address transfer status.</p>
   42     42   
    pub fn address_transfer_status(&self) -> ::std::option::Option<&crate::types::AddressTransferStatus> {
   43     43   
        self.address_transfer_status.as_ref()
   44     44   
    }
   45     45   
}
   46     46   
static ADDRESSTRANSFER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AddressTransfer", "com.amazonaws.ec2", "AddressTransfer");
   48     48   
static ADDRESSTRANSFER_MEMBER_PUBLIC_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AddressTransfer$PublicIp", "com.amazonaws.ec2", "AddressTransfer"),
   50     50   
    ::aws_smithy_schema::ShapeType::String,
   51         -
    "public_ip",
          51  +
    "PublicIp",
   52     52   
    0,
   53     53   
)
   54     54   
.with_xml_name("publicIp");
   55     55   
static ADDRESSTRANSFER_MEMBER_ALLOCATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AddressTransfer$AllocationId", "com.amazonaws.ec2", "AddressTransfer"),
   57     57   
    ::aws_smithy_schema::ShapeType::String,
   58         -
    "allocation_id",
          58  +
    "AllocationId",
   59     59   
    1,
   60     60   
)
   61     61   
.with_xml_name("allocationId");
   62     62   
static ADDRESSTRANSFER_MEMBER_TRANSFER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.ec2#AddressTransfer$TransferAccountId",
   65     65   
        "com.amazonaws.ec2",
   66     66   
        "AddressTransfer",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "transfer_account_id",
          69  +
    "TransferAccountId",
   70     70   
    2,
   71     71   
)
   72     72   
.with_xml_name("transferAccountId");
   73     73   
static ADDRESSTRANSFER_MEMBER_TRANSFER_OFFER_EXPIRATION_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.ec2#AddressTransfer$TransferOfferExpirationTimestamp",
   76     76   
        "com.amazonaws.ec2",
   77     77   
        "AddressTransfer",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::Timestamp,
   80         -
    "transfer_offer_expiration_timestamp",
          80  +
    "TransferOfferExpirationTimestamp",
   81     81   
    3,
   82     82   
)
   83     83   
.with_xml_name("transferOfferExpirationTimestamp");
   84     84   
static ADDRESSTRANSFER_MEMBER_TRANSFER_OFFER_ACCEPTED_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "com.amazonaws.ec2#AddressTransfer$TransferOfferAcceptedTimestamp",
   87     87   
        "com.amazonaws.ec2",
   88     88   
        "AddressTransfer",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::Timestamp,
   91         -
    "transfer_offer_accepted_timestamp",
          91  +
    "TransferOfferAcceptedTimestamp",
   92     92   
    4,
   93     93   
)
   94     94   
.with_xml_name("transferOfferAcceptedTimestamp");
   95     95   
static ADDRESSTRANSFER_MEMBER_ADDRESS_TRANSFER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.ec2#AddressTransfer$AddressTransferStatus",
   98     98   
        "com.amazonaws.ec2",
   99     99   
        "AddressTransfer",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::String,
  102         -
    "address_transfer_status",
         102  +
    "AddressTransferStatus",
  103    103   
    5,
  104    104   
)
  105    105   
.with_xml_name("addressTransferStatus");
  106    106   
static ADDRESSTRANSFER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  107    107   
    ADDRESSTRANSFER_SCHEMA_ID,
  108    108   
    ::aws_smithy_schema::ShapeType::Structure,
  109    109   
    &[
  110    110   
        &ADDRESSTRANSFER_MEMBER_PUBLIC_IP,
  111    111   
        &ADDRESSTRANSFER_MEMBER_ALLOCATION_ID,
  112    112   
        &ADDRESSTRANSFER_MEMBER_TRANSFER_ACCOUNT_ID,
  113    113   
        &ADDRESSTRANSFER_MEMBER_TRANSFER_OFFER_EXPIRATION_TIMESTAMP,
  114    114   
        &ADDRESSTRANSFER_MEMBER_TRANSFER_OFFER_ACCEPTED_TIMESTAMP,
  115    115   
        &ADDRESSTRANSFER_MEMBER_ADDRESS_TRANSFER_STATUS,
  116    116   
    ],
  117    117   
);
  118    118   
impl AddressTransfer {
  119    119   
    /// The schema for this shape.
  120    120   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ADDRESSTRANSFER_SCHEMA;
  121    121   
}
  122    122   
impl ::aws_smithy_schema::serde::SerializableStruct for AddressTransfer {
  123    123   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  124    124   
    fn serialize_members(
  125    125   
        &self,
  126    126   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  127    127   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  128    128   
        if let Some(ref val) = self.public_ip {
  129    129   
            ser.write_string(&ADDRESSTRANSFER_MEMBER_PUBLIC_IP, val)?;
  130    130   
        }
  131    131   
        if let Some(ref val) = self.allocation_id {
  132    132   
            ser.write_string(&ADDRESSTRANSFER_MEMBER_ALLOCATION_ID, val)?;
  133    133   
        }
  134    134   
        if let Some(ref val) = self.transfer_account_id {
  135    135   
            ser.write_string(&ADDRESSTRANSFER_MEMBER_TRANSFER_ACCOUNT_ID, val)?;
  136    136   
        }
  137    137   
        if let Some(ref val) = self.transfer_offer_expiration_timestamp {
  138    138   
            ser.write_timestamp(&ADDRESSTRANSFER_MEMBER_TRANSFER_OFFER_EXPIRATION_TIMESTAMP, val)?;
  139    139   
        }
  140    140   
        if let Some(ref val) = self.transfer_offer_accepted_timestamp {
  141    141   
            ser.write_timestamp(&ADDRESSTRANSFER_MEMBER_TRANSFER_OFFER_ACCEPTED_TIMESTAMP, val)?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.address_transfer_status {
  144    144   
            ser.write_string(&ADDRESSTRANSFER_MEMBER_ADDRESS_TRANSFER_STATUS, val.as_str())?;
  145    145   
        }
  146    146   
        Ok(())
  147    147   
    }
  148    148   
}
  149    149   
impl AddressTransfer {
  150    150   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  151         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  152         -
        deserializer: &mut D,
         151  +
    pub fn deserialize(
         152  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  153    153   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  154    154   
        #[allow(unused_variables, unused_mut)]
  155    155   
        let mut builder = Self::builder();
  156    156   
        #[allow(
  157    157   
            unused_variables,
  158    158   
            unreachable_code,
  159    159   
            clippy::single_match,
  160    160   
            clippy::match_single_binding,
  161    161   
            clippy::diverging_sub_expression
  162    162   
        )]
  163         -
        deserializer.read_struct(&ADDRESSTRANSFER_SCHEMA, (), |_, member, deser| {
         163  +
        deserializer.read_struct(&ADDRESSTRANSFER_SCHEMA, &mut |member, deser| {
  164    164   
            match member.member_index() {
  165    165   
                Some(0) => {
  166    166   
                    builder.public_ip = Some(deser.read_string(member)?);
  167    167   
                }
  168    168   
                Some(1) => {
  169    169   
                    builder.allocation_id = Some(deser.read_string(member)?);
  170    170   
                }
  171    171   
                Some(2) => {
  172    172   
                    builder.transfer_account_id = Some(deser.read_string(member)?);
  173    173   
                }
  174    174   
                Some(3) => {
  175    175   
                    builder.transfer_offer_expiration_timestamp = Some(deser.read_timestamp(member)?);
  176    176   
                }
  177    177   
                Some(4) => {
  178    178   
                    builder.transfer_offer_accepted_timestamp = Some(deser.read_timestamp(member)?);
  179    179   
                }
  180    180   
                Some(5) => {
  181    181   
                    builder.address_transfer_status = Some(crate::types::AddressTransferStatus::from(deser.read_string(member)?.as_str()));
  182    182   
                }
  183    183   
                _ => {}
  184    184   
            }
  185    185   
            Ok(())
  186    186   
        })?;
  187    187   
        Ok(builder.build())
  188    188   
    }
  189    189   
}
         190  +
impl AddressTransfer {
         191  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         192  +
    pub fn deserialize_with_response(
         193  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         194  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         195  +
        _status: u16,
         196  +
        _body: &[u8],
         197  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         198  +
        Self::deserialize(deserializer)
         199  +
    }
         200  +
}
  190    201   
impl AddressTransfer {
  191    202   
    /// Creates a new builder-style object to manufacture [`AddressTransfer`](crate::types::AddressTransfer).
  192    203   
    pub fn builder() -> crate::types::builders::AddressTransferBuilder {
  193    204   
        crate::types::builders::AddressTransferBuilder::default()
  194    205   
    }
  195    206   
}
  196    207   
  197    208   
/// A builder for [`AddressTransfer`](crate::types::AddressTransfer).
  198    209   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  199    210   
#[non_exhaustive]

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

@@ -21,21 +211,219 @@
   41     41   
}
   42     42   
static ALLOWEDPRINCIPAL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   43     43   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AllowedPrincipal", "com.amazonaws.ec2", "AllowedPrincipal");
   44     44   
static ALLOWEDPRINCIPAL_MEMBER_PRINCIPAL_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static(
   46     46   
        "com.amazonaws.ec2#AllowedPrincipal$PrincipalType",
   47     47   
        "com.amazonaws.ec2",
   48     48   
        "AllowedPrincipal",
   49     49   
    ),
   50     50   
    ::aws_smithy_schema::ShapeType::String,
   51         -
    "principal_type",
          51  +
    "PrincipalType",
   52     52   
    0,
   53     53   
)
   54     54   
.with_xml_name("principalType");
   55     55   
static ALLOWEDPRINCIPAL_MEMBER_PRINCIPAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AllowedPrincipal$Principal", "com.amazonaws.ec2", "AllowedPrincipal"),
   57     57   
    ::aws_smithy_schema::ShapeType::String,
   58         -
    "principal",
          58  +
    "Principal",
   59     59   
    1,
   60     60   
)
   61     61   
.with_xml_name("principal");
   62     62   
static ALLOWEDPRINCIPAL_MEMBER_SERVICE_PERMISSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.ec2#AllowedPrincipal$ServicePermissionId",
   65     65   
        "com.amazonaws.ec2",
   66     66   
        "AllowedPrincipal",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "service_permission_id",
          69  +
    "ServicePermissionId",
   70     70   
    2,
   71     71   
)
   72     72   
.with_xml_name("servicePermissionId");
   73     73   
static ALLOWEDPRINCIPAL_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AllowedPrincipal$Tags", "com.amazonaws.ec2", "AllowedPrincipal"),
   75     75   
    ::aws_smithy_schema::ShapeType::List,
   76         -
    "tags",
          76  +
    "Tags",
   77     77   
    3,
   78     78   
)
   79     79   
.with_xml_name("tagSet");
   80     80   
static ALLOWEDPRINCIPAL_MEMBER_SERVICE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AllowedPrincipal$ServiceId", "com.amazonaws.ec2", "AllowedPrincipal"),
   82     82   
    ::aws_smithy_schema::ShapeType::String,
   83         -
    "service_id",
          83  +
    "ServiceId",
   84     84   
    4,
   85     85   
)
   86     86   
.with_xml_name("serviceId");
   87     87   
static ALLOWEDPRINCIPAL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   88     88   
    ALLOWEDPRINCIPAL_SCHEMA_ID,
   89     89   
    ::aws_smithy_schema::ShapeType::Structure,
   90     90   
    &[
   91     91   
        &ALLOWEDPRINCIPAL_MEMBER_PRINCIPAL_TYPE,
   92     92   
        &ALLOWEDPRINCIPAL_MEMBER_PRINCIPAL,
   93     93   
        &ALLOWEDPRINCIPAL_MEMBER_SERVICE_PERMISSION_ID,
   94     94   
        &ALLOWEDPRINCIPAL_MEMBER_TAGS,
   95     95   
        &ALLOWEDPRINCIPAL_MEMBER_SERVICE_ID,
   96     96   
    ],
   97     97   
);
   98     98   
impl AllowedPrincipal {
   99     99   
    /// The schema for this shape.
  100    100   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ALLOWEDPRINCIPAL_SCHEMA;
  101    101   
}
  102    102   
impl ::aws_smithy_schema::serde::SerializableStruct for AllowedPrincipal {
  103    103   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  104    104   
    fn serialize_members(
  105    105   
        &self,
  106    106   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  107    107   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  108    108   
        if let Some(ref val) = self.principal_type {
  109    109   
            ser.write_string(&ALLOWEDPRINCIPAL_MEMBER_PRINCIPAL_TYPE, val.as_str())?;
  110    110   
        }
  111    111   
        if let Some(ref val) = self.principal {
  112    112   
            ser.write_string(&ALLOWEDPRINCIPAL_MEMBER_PRINCIPAL, val)?;
  113    113   
        }
  114    114   
        if let Some(ref val) = self.service_permission_id {
  115    115   
            ser.write_string(&ALLOWEDPRINCIPAL_MEMBER_SERVICE_PERMISSION_ID, val)?;
  116    116   
        }
  117    117   
        if let Some(ref val) = self.tags {
  118    118   
            ser.write_list(
  119    119   
                &ALLOWEDPRINCIPAL_MEMBER_TAGS,
  120    120   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  121    121   
                    for item in val {
  122    122   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  123    123   
                    }
  124    124   
                    Ok(())
  125    125   
                },
  126    126   
            )?;
  127    127   
        }
  128    128   
        if let Some(ref val) = self.service_id {
  129    129   
            ser.write_string(&ALLOWEDPRINCIPAL_MEMBER_SERVICE_ID, val)?;
  130    130   
        }
  131    131   
        Ok(())
  132    132   
    }
  133    133   
}
  134    134   
impl AllowedPrincipal {
  135    135   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  136         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  137         -
        deserializer: &mut D,
         136  +
    pub fn deserialize(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  138    138   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  139    139   
        #[allow(unused_variables, unused_mut)]
  140    140   
        let mut builder = Self::builder();
  141    141   
        #[allow(
  142    142   
            unused_variables,
  143    143   
            unreachable_code,
  144    144   
            clippy::single_match,
  145    145   
            clippy::match_single_binding,
  146    146   
            clippy::diverging_sub_expression
  147    147   
        )]
  148         -
        deserializer.read_struct(&ALLOWEDPRINCIPAL_SCHEMA, (), |_, member, deser| {
         148  +
        deserializer.read_struct(&ALLOWEDPRINCIPAL_SCHEMA, &mut |member, deser| {
  149    149   
            match member.member_index() {
  150    150   
                Some(0) => {
  151    151   
                    builder.principal_type = Some(crate::types::PrincipalType::from(deser.read_string(member)?.as_str()));
  152    152   
                }
  153    153   
                Some(1) => {
  154    154   
                    builder.principal = Some(deser.read_string(member)?);
  155    155   
                }
  156    156   
                Some(2) => {
  157    157   
                    builder.service_permission_id = Some(deser.read_string(member)?);
  158    158   
                }
  159    159   
                Some(3) => {
  160    160   
                    builder.tags = Some({
  161         -
                        let container = if let Some(cap) = deser.container_size() {
  162         -
                            Vec::with_capacity(cap)
  163         -
                        } else {
  164         -
                            Vec::new()
  165         -
                        };
  166         -
                        deser.read_list(member, container, |mut list, deser| {
  167         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  168         -
                            Ok(list)
  169         -
                        })?
         161  +
                        let mut container = Vec::new();
         162  +
                        deser.read_list(member, &mut |deser| {
         163  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         164  +
                            Ok(())
         165  +
                        })?;
         166  +
                        container
  170    167   
                    });
  171    168   
                }
  172    169   
                Some(4) => {
  173    170   
                    builder.service_id = Some(deser.read_string(member)?);
  174    171   
                }
  175    172   
                _ => {}
  176    173   
            }
  177    174   
            Ok(())
  178    175   
        })?;
  179    176   
        Ok(builder.build())
  180    177   
    }
  181    178   
}
         179  +
impl AllowedPrincipal {
         180  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         181  +
    pub fn deserialize_with_response(
         182  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         183  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         184  +
        _status: u16,
         185  +
        _body: &[u8],
         186  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         187  +
        Self::deserialize(deserializer)
         188  +
    }
         189  +
}
  182    190   
impl AllowedPrincipal {
  183    191   
    /// Creates a new builder-style object to manufacture [`AllowedPrincipal`](crate::types::AllowedPrincipal).
  184    192   
    pub fn builder() -> crate::types::builders::AllowedPrincipalBuilder {
  185    193   
        crate::types::builders::AllowedPrincipalBuilder::default()
  186    194   
    }
  187    195   
}
  188    196   
  189    197   
/// A builder for [`AllowedPrincipal`](crate::types::AllowedPrincipal).
  190    198   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  191    199   
#[non_exhaustive]

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

@@ -1,1 +128,139 @@
   21     21   
}
   22     22   
static ALTERNATEPATHHINT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AlternatePathHint", "com.amazonaws.ec2", "AlternatePathHint");
   24     24   
static ALTERNATEPATHHINT_MEMBER_COMPONENT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static(
   26     26   
        "com.amazonaws.ec2#AlternatePathHint$ComponentId",
   27     27   
        "com.amazonaws.ec2",
   28     28   
        "AlternatePathHint",
   29     29   
    ),
   30     30   
    ::aws_smithy_schema::ShapeType::String,
   31         -
    "component_id",
          31  +
    "ComponentId",
   32     32   
    0,
   33     33   
)
   34     34   
.with_xml_name("componentId");
   35     35   
static ALTERNATEPATHHINT_MEMBER_COMPONENT_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   36     36   
    ::aws_smithy_schema::ShapeId::from_static(
   37     37   
        "com.amazonaws.ec2#AlternatePathHint$ComponentArn",
   38     38   
        "com.amazonaws.ec2",
   39     39   
        "AlternatePathHint",
   40     40   
    ),
   41     41   
    ::aws_smithy_schema::ShapeType::String,
   42         -
    "component_arn",
          42  +
    "ComponentArn",
   43     43   
    1,
   44     44   
)
   45     45   
.with_xml_name("componentArn");
   46     46   
static ALTERNATEPATHHINT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   47     47   
    ALTERNATEPATHHINT_SCHEMA_ID,
   48     48   
    ::aws_smithy_schema::ShapeType::Structure,
   49     49   
    &[&ALTERNATEPATHHINT_MEMBER_COMPONENT_ID, &ALTERNATEPATHHINT_MEMBER_COMPONENT_ARN],
   50     50   
);
   51     51   
impl AlternatePathHint {
   52     52   
    /// The schema for this shape.
   53     53   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ALTERNATEPATHHINT_SCHEMA;
   54     54   
}
   55     55   
impl ::aws_smithy_schema::serde::SerializableStruct for AlternatePathHint {
   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.component_id {
   62     62   
            ser.write_string(&ALTERNATEPATHHINT_MEMBER_COMPONENT_ID, val)?;
   63     63   
        }
   64     64   
        if let Some(ref val) = self.component_arn {
   65     65   
            ser.write_string(&ALTERNATEPATHHINT_MEMBER_COMPONENT_ARN, val)?;
   66     66   
        }
   67     67   
        Ok(())
   68     68   
    }
   69     69   
}
   70     70   
impl AlternatePathHint {
   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(&ALTERNATEPATHHINT_SCHEMA, (), |_, member, deser| {
          84  +
        deserializer.read_struct(&ALTERNATEPATHHINT_SCHEMA, &mut |member, deser| {
   85     85   
            match member.member_index() {
   86     86   
                Some(0) => {
   87     87   
                    builder.component_id = Some(deser.read_string(member)?);
   88     88   
                }
   89     89   
                Some(1) => {
   90     90   
                    builder.component_arn = 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 AlternatePathHint {
         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 AlternatePathHint {
  100    111   
    /// Creates a new builder-style object to manufacture [`AlternatePathHint`](crate::types::AlternatePathHint).
  101    112   
    pub fn builder() -> crate::types::builders::AlternatePathHintBuilder {
  102    113   
        crate::types::builders::AlternatePathHintBuilder::default()
  103    114   
    }
  104    115   
}
  105    116   
  106    117   
/// A builder for [`AlternatePathHint`](crate::types::AlternatePathHint).
  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/_analysis_acl_rule.rs

@@ -21,21 +203,214 @@
   41     41   
    /// <p>The rule number.</p>
   42     42   
    pub fn rule_number(&self) -> ::std::option::Option<i32> {
   43     43   
        self.rule_number
   44     44   
    }
   45     45   
}
   46     46   
static ANALYSISACLRULE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AnalysisAclRule", "com.amazonaws.ec2", "AnalysisAclRule");
   48     48   
static ANALYSISACLRULE_MEMBER_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AnalysisAclRule$Cidr", "com.amazonaws.ec2", "AnalysisAclRule"),
   50     50   
    ::aws_smithy_schema::ShapeType::String,
   51         -
    "cidr",
          51  +
    "Cidr",
   52     52   
    0,
   53     53   
)
   54     54   
.with_xml_name("cidr");
   55     55   
static ANALYSISACLRULE_MEMBER_EGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AnalysisAclRule$Egress", "com.amazonaws.ec2", "AnalysisAclRule"),
   57     57   
    ::aws_smithy_schema::ShapeType::Boolean,
   58         -
    "egress",
          58  +
    "Egress",
   59     59   
    1,
   60     60   
)
   61     61   
.with_xml_name("egress");
   62     62   
static ANALYSISACLRULE_MEMBER_PORT_RANGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AnalysisAclRule$PortRange", "com.amazonaws.ec2", "AnalysisAclRule"),
   64     64   
    ::aws_smithy_schema::ShapeType::Structure,
   65         -
    "port_range",
          65  +
    "PortRange",
   66     66   
    2,
   67     67   
)
   68     68   
.with_xml_name("portRange");
   69     69   
static ANALYSISACLRULE_MEMBER_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AnalysisAclRule$Protocol", "com.amazonaws.ec2", "AnalysisAclRule"),
   71     71   
    ::aws_smithy_schema::ShapeType::String,
   72         -
    "protocol",
          72  +
    "Protocol",
   73     73   
    3,
   74     74   
)
   75     75   
.with_xml_name("protocol");
   76     76   
static ANALYSISACLRULE_MEMBER_RULE_ACTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   77     77   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AnalysisAclRule$RuleAction", "com.amazonaws.ec2", "AnalysisAclRule"),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "rule_action",
          79  +
    "RuleAction",
   80     80   
    4,
   81     81   
)
   82     82   
.with_xml_name("ruleAction");
   83     83   
static ANALYSISACLRULE_MEMBER_RULE_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AnalysisAclRule$RuleNumber", "com.amazonaws.ec2", "AnalysisAclRule"),
   85     85   
    ::aws_smithy_schema::ShapeType::Integer,
   86         -
    "rule_number",
          86  +
    "RuleNumber",
   87     87   
    5,
   88     88   
)
   89     89   
.with_xml_name("ruleNumber");
   90     90   
static ANALYSISACLRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   91     91   
    ANALYSISACLRULE_SCHEMA_ID,
   92     92   
    ::aws_smithy_schema::ShapeType::Structure,
   93     93   
    &[
   94     94   
        &ANALYSISACLRULE_MEMBER_CIDR,
   95     95   
        &ANALYSISACLRULE_MEMBER_EGRESS,
   96     96   
        &ANALYSISACLRULE_MEMBER_PORT_RANGE,
   97     97   
        &ANALYSISACLRULE_MEMBER_PROTOCOL,
   98     98   
        &ANALYSISACLRULE_MEMBER_RULE_ACTION,
   99     99   
        &ANALYSISACLRULE_MEMBER_RULE_NUMBER,
  100    100   
    ],
  101    101   
);
  102    102   
impl AnalysisAclRule {
  103    103   
    /// The schema for this shape.
  104    104   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ANALYSISACLRULE_SCHEMA;
  105    105   
}
  106    106   
impl ::aws_smithy_schema::serde::SerializableStruct for AnalysisAclRule {
  107    107   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  108    108   
    fn serialize_members(
  109    109   
        &self,
  110    110   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  111    111   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  112    112   
        if let Some(ref val) = self.cidr {
  113    113   
            ser.write_string(&ANALYSISACLRULE_MEMBER_CIDR, val)?;
  114    114   
        }
  115    115   
        if let Some(ref val) = self.egress {
  116    116   
            ser.write_boolean(&ANALYSISACLRULE_MEMBER_EGRESS, *val)?;
  117    117   
        }
  118    118   
        if let Some(ref val) = self.port_range {
  119    119   
            ser.write_struct(&ANALYSISACLRULE_MEMBER_PORT_RANGE, val)?;
  120    120   
        }
  121    121   
        if let Some(ref val) = self.protocol {
  122    122   
            ser.write_string(&ANALYSISACLRULE_MEMBER_PROTOCOL, val)?;
  123    123   
        }
  124    124   
        if let Some(ref val) = self.rule_action {
  125    125   
            ser.write_string(&ANALYSISACLRULE_MEMBER_RULE_ACTION, val)?;
  126    126   
        }
  127    127   
        if let Some(ref val) = self.rule_number {
  128    128   
            ser.write_integer(&ANALYSISACLRULE_MEMBER_RULE_NUMBER, *val)?;
  129    129   
        }
  130    130   
        Ok(())
  131    131   
    }
  132    132   
}
  133    133   
impl AnalysisAclRule {
  134    134   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  135         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  136         -
        deserializer: &mut D,
         135  +
    pub fn deserialize(
         136  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  137    137   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  138    138   
        #[allow(unused_variables, unused_mut)]
  139    139   
        let mut builder = Self::builder();
  140    140   
        #[allow(
  141    141   
            unused_variables,
  142    142   
            unreachable_code,
  143    143   
            clippy::single_match,
  144    144   
            clippy::match_single_binding,
  145    145   
            clippy::diverging_sub_expression
  146    146   
        )]
  147         -
        deserializer.read_struct(&ANALYSISACLRULE_SCHEMA, (), |_, member, deser| {
         147  +
        deserializer.read_struct(&ANALYSISACLRULE_SCHEMA, &mut |member, deser| {
  148    148   
            match member.member_index() {
  149    149   
                Some(0) => {
  150    150   
                    builder.cidr = Some(deser.read_string(member)?);
  151    151   
                }
  152    152   
                Some(1) => {
  153    153   
                    builder.egress = Some(deser.read_boolean(member)?);
  154    154   
                }
  155    155   
                Some(2) => {
  156    156   
                    builder.port_range = Some(crate::types::PortRange::deserialize(deser)?);
  157    157   
                }
  158    158   
                Some(3) => {
  159    159   
                    builder.protocol = Some(deser.read_string(member)?);
  160    160   
                }
  161    161   
                Some(4) => {
  162    162   
                    builder.rule_action = Some(deser.read_string(member)?);
  163    163   
                }
  164    164   
                Some(5) => {
  165    165   
                    builder.rule_number = Some(deser.read_integer(member)?);
  166    166   
                }
  167    167   
                _ => {}
  168    168   
            }
  169    169   
            Ok(())
  170    170   
        })?;
  171    171   
        Ok(builder.build())
  172    172   
    }
  173    173   
}
         174  +
impl AnalysisAclRule {
         175  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         176  +
    pub fn deserialize_with_response(
         177  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         178  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         179  +
        _status: u16,
         180  +
        _body: &[u8],
         181  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         182  +
        Self::deserialize(deserializer)
         183  +
    }
         184  +
}
  174    185   
impl AnalysisAclRule {
  175    186   
    /// Creates a new builder-style object to manufacture [`AnalysisAclRule`](crate::types::AnalysisAclRule).
  176    187   
    pub fn builder() -> crate::types::builders::AnalysisAclRuleBuilder {
  177    188   
        crate::types::builders::AnalysisAclRuleBuilder::default()
  178    189   
    }
  179    190   
}
  180    191   
  181    192   
/// A builder for [`AnalysisAclRule`](crate::types::AnalysisAclRule).
  182    193   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  183    194   
#[non_exhaustive]

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

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

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

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

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

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

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

@@ -27,27 +131,131 @@
   47     47   
}
   48     48   
static ANALYSISPACKETHEADER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#AnalysisPacketHeader", "com.amazonaws.ec2", "AnalysisPacketHeader");
   50     50   
static ANALYSISPACKETHEADER_MEMBER_DESTINATION_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.ec2#AnalysisPacketHeader$DestinationAddresses",
   53     53   
        "com.amazonaws.ec2",
   54     54   
        "AnalysisPacketHeader",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::List,
   57         -
    "destination_addresses",
          57  +
    "DestinationAddresses",
   58     58   
    0,
   59     59   
)
   60     60   
.with_xml_name("destinationAddressSet");
   61     61   
static ANALYSISPACKETHEADER_MEMBER_DESTINATION_PORT_RANGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.ec2#AnalysisPacketHeader$DestinationPortRanges",
   64     64   
        "com.amazonaws.ec2",
   65     65   
        "AnalysisPacketHeader",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::List,
   68         -
    "destination_port_ranges",
          68  +
    "DestinationPortRanges",
   69     69   
    1,
   70     70   
)
   71     71   
.with_xml_name("destinationPortRangeSet");
   72     72   
static ANALYSISPACKETHEADER_MEMBER_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.ec2#AnalysisPacketHeader$Protocol",
   75     75   
        "com.amazonaws.ec2",
   76     76   
        "AnalysisPacketHeader",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "protocol",
          79  +
    "Protocol",
   80     80   
    2,
   81     81   
)
   82     82   
.with_xml_name("protocol");
   83     83   
static ANALYSISPACKETHEADER_MEMBER_SOURCE_ADDRESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.ec2#AnalysisPacketHeader$SourceAddresses",
   86     86   
        "com.amazonaws.ec2",
   87     87   
        "AnalysisPacketHeader",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::List,
   90         -
    "source_addresses",
          90  +
    "SourceAddresses",
   91     91   
    3,
   92     92   
)
   93     93   
.with_xml_name("sourceAddressSet");
   94     94   
static ANALYSISPACKETHEADER_MEMBER_SOURCE_PORT_RANGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static(
   96     96   
        "com.amazonaws.ec2#AnalysisPacketHeader$SourcePortRanges",
   97     97   
        "com.amazonaws.ec2",
   98     98   
        "AnalysisPacketHeader",
   99     99   
    ),
  100    100   
    ::aws_smithy_schema::ShapeType::List,
  101         -
    "source_port_ranges",
         101  +
    "SourcePortRanges",
  102    102   
    4,
  103    103   
)
  104    104   
.with_xml_name("sourcePortRangeSet");
  105    105   
static ANALYSISPACKETHEADER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  106    106   
    ANALYSISPACKETHEADER_SCHEMA_ID,
  107    107   
    ::aws_smithy_schema::ShapeType::Structure,
  108    108   
    &[
  109    109   
        &ANALYSISPACKETHEADER_MEMBER_DESTINATION_ADDRESSES,
  110    110   
        &ANALYSISPACKETHEADER_MEMBER_DESTINATION_PORT_RANGES,
  111    111   
        &ANALYSISPACKETHEADER_MEMBER_PROTOCOL,
@@ -148,148 +283,268 @@
  168    168   
                    }
  169    169   
                    Ok(())
  170    170   
                },
  171    171   
            )?;
  172    172   
        }
  173    173   
        Ok(())
  174    174   
    }
  175    175   
}
  176    176   
impl AnalysisPacketHeader {
  177    177   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  178         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  179         -
        deserializer: &mut D,
         178  +
    pub fn deserialize(
         179  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  180    180   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  181    181   
        #[allow(unused_variables, unused_mut)]
  182    182   
        let mut builder = Self::builder();
  183    183   
        #[allow(
  184    184   
            unused_variables,
  185    185   
            unreachable_code,
  186    186   
            clippy::single_match,
  187    187   
            clippy::match_single_binding,
  188    188   
            clippy::diverging_sub_expression
  189    189   
        )]
  190         -
        deserializer.read_struct(&ANALYSISPACKETHEADER_SCHEMA, (), |_, member, deser| {
         190  +
        deserializer.read_struct(&ANALYSISPACKETHEADER_SCHEMA, &mut |member, deser| {
  191    191   
            match member.member_index() {
  192    192   
                Some(0) => {
  193         -
                    builder.destination_addresses = Some({
  194         -
                        let container = if let Some(cap) = deser.container_size() {
  195         -
                            Vec::with_capacity(cap)
  196         -
                        } else {
  197         -
                            Vec::new()
  198         -
                        };
  199         -
                        deser.read_list(member, container, |mut list, deser| {
  200         -
                            list.push(deser.read_string(member)?);
  201         -
                            Ok(list)
  202         -
                        })?
  203         -
                    });
         193  +
                    builder.destination_addresses = Some(deser.read_string_list(member)?);
  204    194   
                }
  205    195   
                Some(1) => {
  206    196   
                    builder.destination_port_ranges = Some({
  207         -
                        let container = if let Some(cap) = deser.container_size() {
  208         -
                            Vec::with_capacity(cap)
  209         -
                        } else {
  210         -
                            Vec::new()
  211         -
                        };
  212         -
                        deser.read_list(member, container, |mut list, deser| {
  213         -
                            list.push(crate::types::PortRange::deserialize(deser)?);
  214         -
                            Ok(list)
  215         -
                        })?
         197  +
                        let mut container = Vec::new();
         198  +
                        deser.read_list(member, &mut |deser| {
         199  +
                            container.push(crate::types::PortRange::deserialize(deser)?);
         200  +
                            Ok(())
         201  +
                        })?;
         202  +
                        container
  216    203   
                    });
  217    204   
                }
  218    205   
                Some(2) => {
  219    206   
                    builder.protocol = Some(deser.read_string(member)?);
  220    207   
                }
  221    208   
                Some(3) => {
  222         -
                    builder.source_addresses = Some({
  223         -
                        let container = if let Some(cap) = deser.container_size() {
  224         -
                            Vec::with_capacity(cap)
  225         -
                        } else {
  226         -
                            Vec::new()
  227         -
                        };
  228         -
                        deser.read_list(member, container, |mut list, deser| {
  229         -
                            list.push(deser.read_string(member)?);
  230         -
                            Ok(list)
  231         -
                        })?
  232         -
                    });
         209  +
                    builder.source_addresses = Some(deser.read_string_list(member)?);
  233    210   
                }
  234    211   
                Some(4) => {
  235    212   
                    builder.source_port_ranges = Some({
  236         -
                        let container = if let Some(cap) = deser.container_size() {
  237         -
                            Vec::with_capacity(cap)
  238         -
                        } else {
  239         -
                            Vec::new()
  240         -
                        };
  241         -
                        deser.read_list(member, container, |mut list, deser| {
  242         -
                            list.push(crate::types::PortRange::deserialize(deser)?);
  243         -
                            Ok(list)
  244         -
                        })?
         213  +
                        let mut container = Vec::new();
         214  +
                        deser.read_list(member, &mut |deser| {
         215  +
                            container.push(crate::types::PortRange::deserialize(deser)?);
         216  +
                            Ok(())
         217  +
                        })?;
         218  +
                        container
  245    219   
                    });
  246    220   
                }
  247    221   
                _ => {}
  248    222   
            }
  249    223   
            Ok(())
  250    224   
        })?;
  251    225   
        Ok(builder.build())
  252    226   
    }
  253    227   
}
         228  +
impl AnalysisPacketHeader {
         229  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         230  +
    pub fn deserialize_with_response(
         231  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         232  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         233  +
        _status: u16,
         234  +
        _body: &[u8],
         235  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         236  +
        Self::deserialize(deserializer)
         237  +
    }
         238  +
}
  254    239   
impl AnalysisPacketHeader {
  255    240   
    /// Creates a new builder-style object to manufacture [`AnalysisPacketHeader`](crate::types::AnalysisPacketHeader).
  256    241   
    pub fn builder() -> crate::types::builders::AnalysisPacketHeaderBuilder {
  257    242   
        crate::types::builders::AnalysisPacketHeaderBuilder::default()
  258    243   
    }
  259    244   
}
  260    245   
  261    246   
/// A builder for [`AnalysisPacketHeader`](crate::types::AnalysisPacketHeader).
  262    247   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  263    248   
#[non_exhaustive]

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

@@ -104,104 +307,307 @@
  124    124   
    "com.amazonaws.ec2",
  125    125   
    "AnalysisRouteTableRoute",
  126    126   
);
  127    127   
static ANALYSISROUTETABLEROUTE_MEMBER_DESTINATION_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static(
  129    129   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$DestinationCidr",
  130    130   
        "com.amazonaws.ec2",
  131    131   
        "AnalysisRouteTableRoute",
  132    132   
    ),
  133    133   
    ::aws_smithy_schema::ShapeType::String,
  134         -
    "destination_cidr",
         134  +
    "DestinationCidr",
  135    135   
    0,
  136    136   
)
  137    137   
.with_xml_name("destinationCidr");
  138    138   
static ANALYSISROUTETABLEROUTE_MEMBER_DESTINATION_PREFIX_LIST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  139    139   
    ::aws_smithy_schema::ShapeId::from_static(
  140    140   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$DestinationPrefixListId",
  141    141   
        "com.amazonaws.ec2",
  142    142   
        "AnalysisRouteTableRoute",
  143    143   
    ),
  144    144   
    ::aws_smithy_schema::ShapeType::String,
  145         -
    "destination_prefix_list_id",
         145  +
    "DestinationPrefixListId",
  146    146   
    1,
  147    147   
)
  148    148   
.with_xml_name("destinationPrefixListId");
  149    149   
static ANALYSISROUTETABLEROUTE_MEMBER_EGRESS_ONLY_INTERNET_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static(
  151    151   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$EgressOnlyInternetGatewayId",
  152    152   
        "com.amazonaws.ec2",
  153    153   
        "AnalysisRouteTableRoute",
  154    154   
    ),
  155    155   
    ::aws_smithy_schema::ShapeType::String,
  156         -
    "egress_only_internet_gateway_id",
         156  +
    "EgressOnlyInternetGatewayId",
  157    157   
    2,
  158    158   
)
  159    159   
.with_xml_name("egressOnlyInternetGatewayId");
  160    160   
static ANALYSISROUTETABLEROUTE_MEMBER_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  161    161   
    ::aws_smithy_schema::ShapeId::from_static(
  162    162   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$GatewayId",
  163    163   
        "com.amazonaws.ec2",
  164    164   
        "AnalysisRouteTableRoute",
  165    165   
    ),
  166    166   
    ::aws_smithy_schema::ShapeType::String,
  167         -
    "gateway_id",
         167  +
    "GatewayId",
  168    168   
    3,
  169    169   
)
  170    170   
.with_xml_name("gatewayId");
  171    171   
static ANALYSISROUTETABLEROUTE_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  172    172   
    ::aws_smithy_schema::ShapeId::from_static(
  173    173   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$InstanceId",
  174    174   
        "com.amazonaws.ec2",
  175    175   
        "AnalysisRouteTableRoute",
  176    176   
    ),
  177    177   
    ::aws_smithy_schema::ShapeType::String,
  178         -
    "instance_id",
         178  +
    "InstanceId",
  179    179   
    4,
  180    180   
)
  181    181   
.with_xml_name("instanceId");
  182    182   
static ANALYSISROUTETABLEROUTE_MEMBER_NAT_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  183    183   
    ::aws_smithy_schema::ShapeId::from_static(
  184    184   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$NatGatewayId",
  185    185   
        "com.amazonaws.ec2",
  186    186   
        "AnalysisRouteTableRoute",
  187    187   
    ),
  188    188   
    ::aws_smithy_schema::ShapeType::String,
  189         -
    "nat_gateway_id",
         189  +
    "NatGatewayId",
  190    190   
    5,
  191    191   
)
  192    192   
.with_xml_name("natGatewayId");
  193    193   
static ANALYSISROUTETABLEROUTE_MEMBER_NETWORK_INTERFACE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  194    194   
    ::aws_smithy_schema::ShapeId::from_static(
  195    195   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$NetworkInterfaceId",
  196    196   
        "com.amazonaws.ec2",
  197    197   
        "AnalysisRouteTableRoute",
  198    198   
    ),
  199    199   
    ::aws_smithy_schema::ShapeType::String,
  200         -
    "network_interface_id",
         200  +
    "NetworkInterfaceId",
  201    201   
    6,
  202    202   
)
  203    203   
.with_xml_name("networkInterfaceId");
  204    204   
static ANALYSISROUTETABLEROUTE_MEMBER_ORIGIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  205    205   
    ::aws_smithy_schema::ShapeId::from_static(
  206    206   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$Origin",
  207    207   
        "com.amazonaws.ec2",
  208    208   
        "AnalysisRouteTableRoute",
  209    209   
    ),
  210    210   
    ::aws_smithy_schema::ShapeType::String,
  211         -
    "origin",
         211  +
    "Origin",
  212    212   
    7,
  213    213   
)
  214    214   
.with_xml_name("origin");
  215    215   
static ANALYSISROUTETABLEROUTE_MEMBER_TRANSIT_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  216    216   
    ::aws_smithy_schema::ShapeId::from_static(
  217    217   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$TransitGatewayId",
  218    218   
        "com.amazonaws.ec2",
  219    219   
        "AnalysisRouteTableRoute",
  220    220   
    ),
  221    221   
    ::aws_smithy_schema::ShapeType::String,
  222         -
    "transit_gateway_id",
         222  +
    "TransitGatewayId",
  223    223   
    8,
  224    224   
)
  225    225   
.with_xml_name("transitGatewayId");
  226    226   
static ANALYSISROUTETABLEROUTE_MEMBER_VPC_PEERING_CONNECTION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  227    227   
    ::aws_smithy_schema::ShapeId::from_static(
  228    228   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$VpcPeeringConnectionId",
  229    229   
        "com.amazonaws.ec2",
  230    230   
        "AnalysisRouteTableRoute",
  231    231   
    ),
  232    232   
    ::aws_smithy_schema::ShapeType::String,
  233         -
    "vpc_peering_connection_id",
         233  +
    "VpcPeeringConnectionId",
  234    234   
    9,
  235    235   
)
  236    236   
.with_xml_name("vpcPeeringConnectionId");
  237    237   
static ANALYSISROUTETABLEROUTE_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  238    238   
    ::aws_smithy_schema::ShapeId::from_static(
  239    239   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$State",
  240    240   
        "com.amazonaws.ec2",
  241    241   
        "AnalysisRouteTableRoute",
  242    242   
    ),
  243    243   
    ::aws_smithy_schema::ShapeType::String,
  244         -
    "state",
         244  +
    "State",
  245    245   
    10,
  246    246   
)
  247    247   
.with_xml_name("state");
  248    248   
static ANALYSISROUTETABLEROUTE_MEMBER_CARRIER_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  249    249   
    ::aws_smithy_schema::ShapeId::from_static(
  250    250   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$CarrierGatewayId",
  251    251   
        "com.amazonaws.ec2",
  252    252   
        "AnalysisRouteTableRoute",
  253    253   
    ),
  254    254   
    ::aws_smithy_schema::ShapeType::String,
  255         -
    "carrier_gateway_id",
         255  +
    "CarrierGatewayId",
  256    256   
    11,
  257    257   
)
  258    258   
.with_xml_name("carrierGatewayId");
  259    259   
static ANALYSISROUTETABLEROUTE_MEMBER_CORE_NETWORK_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  260    260   
    ::aws_smithy_schema::ShapeId::from_static(
  261    261   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$CoreNetworkArn",
  262    262   
        "com.amazonaws.ec2",
  263    263   
        "AnalysisRouteTableRoute",
  264    264   
    ),
  265    265   
    ::aws_smithy_schema::ShapeType::String,
  266         -
    "core_network_arn",
         266  +
    "CoreNetworkArn",
  267    267   
    12,
  268    268   
)
  269    269   
.with_xml_name("coreNetworkArn");
  270    270   
static ANALYSISROUTETABLEROUTE_MEMBER_LOCAL_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  271    271   
    ::aws_smithy_schema::ShapeId::from_static(
  272    272   
        "com.amazonaws.ec2#AnalysisRouteTableRoute$LocalGatewayId",
  273    273   
        "com.amazonaws.ec2",
  274    274   
        "AnalysisRouteTableRoute",
  275    275   
    ),
  276    276   
    ::aws_smithy_schema::ShapeType::String,
  277         -
    "local_gateway_id",
         277  +
    "LocalGatewayId",
  278    278   
    13,
  279    279   
)
  280    280   
.with_xml_name("localGatewayId");
  281    281   
static ANALYSISROUTETABLEROUTE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  282    282   
    ANALYSISROUTETABLEROUTE_SCHEMA_ID,
  283    283   
    ::aws_smithy_schema::ShapeType::Structure,
  284    284   
    &[
  285    285   
        &ANALYSISROUTETABLEROUTE_MEMBER_DESTINATION_CIDR,
  286    286   
        &ANALYSISROUTETABLEROUTE_MEMBER_DESTINATION_PREFIX_LIST_ID,
  287    287   
        &ANALYSISROUTETABLEROUTE_MEMBER_EGRESS_ONLY_INTERNET_GATEWAY_ID,
@@ -328,328 +450,461 @@
  348    348   
            ser.write_string(&ANALYSISROUTETABLEROUTE_MEMBER_CORE_NETWORK_ARN, val)?;
  349    349   
        }
  350    350   
        if let Some(ref val) = self.local_gateway_id {
  351    351   
            ser.write_string(&ANALYSISROUTETABLEROUTE_MEMBER_LOCAL_GATEWAY_ID, val)?;
  352    352   
        }
  353    353   
        Ok(())
  354    354   
    }
  355    355   
}
  356    356   
impl AnalysisRouteTableRoute {
  357    357   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  358         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  359         -
        deserializer: &mut D,
         358  +
    pub fn deserialize(
         359  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  360    360   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  361    361   
        #[allow(unused_variables, unused_mut)]
  362    362   
        let mut builder = Self::builder();
  363    363   
        #[allow(
  364    364   
            unused_variables,
  365    365   
            unreachable_code,
  366    366   
            clippy::single_match,
  367    367   
            clippy::match_single_binding,
  368    368   
            clippy::diverging_sub_expression
  369    369   
        )]
  370         -
        deserializer.read_struct(&ANALYSISROUTETABLEROUTE_SCHEMA, (), |_, member, deser| {
         370  +
        deserializer.read_struct(&ANALYSISROUTETABLEROUTE_SCHEMA, &mut |member, deser| {
  371    371   
            match member.member_index() {
  372    372   
                Some(0) => {
  373    373   
                    builder.destination_cidr = Some(deser.read_string(member)?);
  374    374   
                }
  375    375   
                Some(1) => {
  376    376   
                    builder.destination_prefix_list_id = Some(deser.read_string(member)?);
  377    377   
                }
  378    378   
                Some(2) => {
  379    379   
                    builder.egress_only_internet_gateway_id = Some(deser.read_string(member)?);
  380    380   
                }
  381    381   
                Some(3) => {
  382    382   
                    builder.gateway_id = Some(deser.read_string(member)?);
  383    383   
                }
  384    384   
                Some(4) => {
  385    385   
                    builder.instance_id = Some(deser.read_string(member)?);
  386    386   
                }
  387    387   
                Some(5) => {
  388    388   
                    builder.nat_gateway_id = Some(deser.read_string(member)?);
  389    389   
                }
  390    390   
                Some(6) => {
  391    391   
                    builder.network_interface_id = Some(deser.read_string(member)?);
  392    392   
                }
  393    393   
                Some(7) => {
  394    394   
                    builder.origin = Some(deser.read_string(member)?);
  395    395   
                }
  396    396   
                Some(8) => {
  397    397   
                    builder.transit_gateway_id = Some(deser.read_string(member)?);
  398    398   
                }
  399    399   
                Some(9) => {
  400    400   
                    builder.vpc_peering_connection_id = Some(deser.read_string(member)?);
  401    401   
                }
  402    402   
                Some(10) => {
  403    403   
                    builder.state = Some(deser.read_string(member)?);
  404    404   
                }
  405    405   
                Some(11) => {
  406    406   
                    builder.carrier_gateway_id = Some(deser.read_string(member)?);
  407    407   
                }
  408    408   
                Some(12) => {
  409    409   
                    builder.core_network_arn = Some(deser.read_string(member)?);
  410    410   
                }
  411    411   
                Some(13) => {
  412    412   
                    builder.local_gateway_id = Some(deser.read_string(member)?);
  413    413   
                }
  414    414   
                _ => {}
  415    415   
            }
  416    416   
            Ok(())
  417    417   
        })?;
  418    418   
        Ok(builder.build())
  419    419   
    }
  420    420   
}
         421  +
impl AnalysisRouteTableRoute {
         422  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         423  +
    pub fn deserialize_with_response(
         424  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         425  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         426  +
        _status: u16,
         427  +
        _body: &[u8],
         428  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         429  +
        Self::deserialize(deserializer)
         430  +
    }
         431  +
}
  421    432   
impl AnalysisRouteTableRoute {
  422    433   
    /// Creates a new builder-style object to manufacture [`AnalysisRouteTableRoute`](crate::types::AnalysisRouteTableRoute).
  423    434   
    pub fn builder() -> crate::types::builders::AnalysisRouteTableRouteBuilder {
  424    435   
        crate::types::builders::AnalysisRouteTableRouteBuilder::default()
  425    436   
    }
  426    437   
}
  427    438   
  428    439   
/// A builder for [`AnalysisRouteTableRoute`](crate::types::AnalysisRouteTableRoute).
  429    440   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  430    441   
#[non_exhaustive]

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

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