AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406

Files changed:

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

@@ -11,11 +159,170 @@
   31     31   
}
   32     32   
static CLOUDWATCHLOGOPTIONS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   33     33   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CloudWatchLogOptions", "com.amazonaws.ec2", "CloudWatchLogOptions");
   34     34   
static CLOUDWATCHLOGOPTIONS_MEMBER_LOG_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   35     35   
    ::aws_smithy_schema::ShapeId::from_static(
   36     36   
        "com.amazonaws.ec2#CloudWatchLogOptions$LogEnabled",
   37     37   
        "com.amazonaws.ec2",
   38     38   
        "CloudWatchLogOptions",
   39     39   
    ),
   40     40   
    ::aws_smithy_schema::ShapeType::Boolean,
   41         -
    "log_enabled",
          41  +
    "LogEnabled",
   42     42   
    0,
   43     43   
)
   44     44   
.with_xml_name("logEnabled");
   45     45   
static CLOUDWATCHLOGOPTIONS_MEMBER_LOG_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static(
   47     47   
        "com.amazonaws.ec2#CloudWatchLogOptions$LogGroupArn",
   48     48   
        "com.amazonaws.ec2",
   49     49   
        "CloudWatchLogOptions",
   50     50   
    ),
   51     51   
    ::aws_smithy_schema::ShapeType::String,
   52         -
    "log_group_arn",
          52  +
    "LogGroupArn",
   53     53   
    1,
   54     54   
)
   55     55   
.with_xml_name("logGroupArn");
   56     56   
static CLOUDWATCHLOGOPTIONS_MEMBER_LOG_OUTPUT_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "com.amazonaws.ec2#CloudWatchLogOptions$LogOutputFormat",
   59     59   
        "com.amazonaws.ec2",
   60     60   
        "CloudWatchLogOptions",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "log_output_format",
          63  +
    "LogOutputFormat",
   64     64   
    2,
   65     65   
)
   66     66   
.with_xml_name("logOutputFormat");
   67     67   
static CLOUDWATCHLOGOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   68     68   
    CLOUDWATCHLOGOPTIONS_SCHEMA_ID,
   69     69   
    ::aws_smithy_schema::ShapeType::Structure,
   70     70   
    &[
   71     71   
        &CLOUDWATCHLOGOPTIONS_MEMBER_LOG_ENABLED,
   72     72   
        &CLOUDWATCHLOGOPTIONS_MEMBER_LOG_GROUP_ARN,
   73     73   
        &CLOUDWATCHLOGOPTIONS_MEMBER_LOG_OUTPUT_FORMAT,
   74     74   
    ],
   75     75   
);
   76     76   
impl CloudWatchLogOptions {
   77     77   
    /// The schema for this shape.
   78     78   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CLOUDWATCHLOGOPTIONS_SCHEMA;
   79     79   
}
   80     80   
impl ::aws_smithy_schema::serde::SerializableStruct for CloudWatchLogOptions {
   81     81   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   82     82   
    fn serialize_members(
   83     83   
        &self,
   84     84   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   85     85   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   86     86   
        if let Some(ref val) = self.log_enabled {
   87     87   
            ser.write_boolean(&CLOUDWATCHLOGOPTIONS_MEMBER_LOG_ENABLED, *val)?;
   88     88   
        }
   89     89   
        if let Some(ref val) = self.log_group_arn {
   90     90   
            ser.write_string(&CLOUDWATCHLOGOPTIONS_MEMBER_LOG_GROUP_ARN, val)?;
   91     91   
        }
   92     92   
        if let Some(ref val) = self.log_output_format {
   93     93   
            ser.write_string(&CLOUDWATCHLOGOPTIONS_MEMBER_LOG_OUTPUT_FORMAT, val)?;
   94     94   
        }
   95     95   
        Ok(())
   96     96   
    }
   97     97   
}
   98     98   
impl CloudWatchLogOptions {
   99     99   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  100         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  101         -
        deserializer: &mut D,
         100  +
    pub fn deserialize(
         101  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  102    102   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  103    103   
        #[allow(unused_variables, unused_mut)]
  104    104   
        let mut builder = Self::builder();
  105    105   
        #[allow(
  106    106   
            unused_variables,
  107    107   
            unreachable_code,
  108    108   
            clippy::single_match,
  109    109   
            clippy::match_single_binding,
  110    110   
            clippy::diverging_sub_expression
  111    111   
        )]
  112         -
        deserializer.read_struct(&CLOUDWATCHLOGOPTIONS_SCHEMA, (), |_, member, deser| {
         112  +
        deserializer.read_struct(&CLOUDWATCHLOGOPTIONS_SCHEMA, &mut |member, deser| {
  113    113   
            match member.member_index() {
  114    114   
                Some(0) => {
  115    115   
                    builder.log_enabled = Some(deser.read_boolean(member)?);
  116    116   
                }
  117    117   
                Some(1) => {
  118    118   
                    builder.log_group_arn = Some(deser.read_string(member)?);
  119    119   
                }
  120    120   
                Some(2) => {
  121    121   
                    builder.log_output_format = Some(deser.read_string(member)?);
  122    122   
                }
  123    123   
                _ => {}
  124    124   
            }
  125    125   
            Ok(())
  126    126   
        })?;
  127    127   
        Ok(builder.build())
  128    128   
    }
  129    129   
}
         130  +
impl CloudWatchLogOptions {
         131  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         132  +
    pub fn deserialize_with_response(
         133  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         134  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         135  +
        _status: u16,
         136  +
        _body: &[u8],
         137  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         138  +
        Self::deserialize(deserializer)
         139  +
    }
         140  +
}
  130    141   
impl CloudWatchLogOptions {
  131    142   
    /// Creates a new builder-style object to manufacture [`CloudWatchLogOptions`](crate::types::CloudWatchLogOptions).
  132    143   
    pub fn builder() -> crate::types::builders::CloudWatchLogOptionsBuilder {
  133    144   
        crate::types::builders::CloudWatchLogOptionsBuilder::default()
  134    145   
    }
  135    146   
}
  136    147   
  137    148   
/// A builder for [`CloudWatchLogOptions`](crate::types::CloudWatchLogOptions).
  138    149   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  139    150   
#[non_exhaustive]

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

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

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

@@ -9,9 +163,174 @@
   29     29   
    /// <p>The customer-owned IP address.</p>
   30     30   
    pub fn co_ip(&self) -> ::std::option::Option<&str> {
   31     31   
        self.co_ip.as_deref()
   32     32   
    }
   33     33   
}
   34     34   
static COIPADDRESSUSAGE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   35     35   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipAddressUsage", "com.amazonaws.ec2", "CoipAddressUsage");
   36     36   
static COIPADDRESSUSAGE_MEMBER_ALLOCATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipAddressUsage$AllocationId", "com.amazonaws.ec2", "CoipAddressUsage"),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "allocation_id",
          39  +
    "AllocationId",
   40     40   
    0,
   41     41   
)
   42     42   
.with_xml_name("allocationId");
   43     43   
static COIPADDRESSUSAGE_MEMBER_AWS_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipAddressUsage$AwsAccountId", "com.amazonaws.ec2", "CoipAddressUsage"),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "aws_account_id",
          46  +
    "AwsAccountId",
   47     47   
    1,
   48     48   
)
   49     49   
.with_xml_name("awsAccountId");
   50     50   
static COIPADDRESSUSAGE_MEMBER_AWS_SERVICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipAddressUsage$AwsService", "com.amazonaws.ec2", "CoipAddressUsage"),
   52     52   
    ::aws_smithy_schema::ShapeType::String,
   53         -
    "aws_service",
          53  +
    "AwsService",
   54     54   
    2,
   55     55   
)
   56     56   
.with_xml_name("awsService");
   57     57   
static COIPADDRESSUSAGE_MEMBER_CO_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipAddressUsage$CoIp", "com.amazonaws.ec2", "CoipAddressUsage"),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "co_ip",
          60  +
    "CoIp",
   61     61   
    3,
   62     62   
)
   63     63   
.with_xml_name("coIp");
   64     64   
static COIPADDRESSUSAGE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   65     65   
    COIPADDRESSUSAGE_SCHEMA_ID,
   66     66   
    ::aws_smithy_schema::ShapeType::Structure,
   67     67   
    &[
   68     68   
        &COIPADDRESSUSAGE_MEMBER_ALLOCATION_ID,
   69     69   
        &COIPADDRESSUSAGE_MEMBER_AWS_ACCOUNT_ID,
   70     70   
        &COIPADDRESSUSAGE_MEMBER_AWS_SERVICE,
   71     71   
        &COIPADDRESSUSAGE_MEMBER_CO_IP,
   72     72   
    ],
   73     73   
);
   74     74   
impl CoipAddressUsage {
   75     75   
    /// The schema for this shape.
   76     76   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COIPADDRESSUSAGE_SCHEMA;
   77     77   
}
   78     78   
impl ::aws_smithy_schema::serde::SerializableStruct for CoipAddressUsage {
   79     79   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   80     80   
    fn serialize_members(
   81     81   
        &self,
   82     82   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   83     83   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   84     84   
        if let Some(ref val) = self.allocation_id {
   85     85   
            ser.write_string(&COIPADDRESSUSAGE_MEMBER_ALLOCATION_ID, val)?;
   86     86   
        }
   87     87   
        if let Some(ref val) = self.aws_account_id {
   88     88   
            ser.write_string(&COIPADDRESSUSAGE_MEMBER_AWS_ACCOUNT_ID, val)?;
   89     89   
        }
   90     90   
        if let Some(ref val) = self.aws_service {
   91     91   
            ser.write_string(&COIPADDRESSUSAGE_MEMBER_AWS_SERVICE, val)?;
   92     92   
        }
   93     93   
        if let Some(ref val) = self.co_ip {
   94     94   
            ser.write_string(&COIPADDRESSUSAGE_MEMBER_CO_IP, val)?;
   95     95   
        }
   96     96   
        Ok(())
   97     97   
    }
   98     98   
}
   99     99   
impl CoipAddressUsage {
  100    100   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  101         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  102         -
        deserializer: &mut D,
         101  +
    pub fn deserialize(
         102  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  103    103   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  104    104   
        #[allow(unused_variables, unused_mut)]
  105    105   
        let mut builder = Self::builder();
  106    106   
        #[allow(
  107    107   
            unused_variables,
  108    108   
            unreachable_code,
  109    109   
            clippy::single_match,
  110    110   
            clippy::match_single_binding,
  111    111   
            clippy::diverging_sub_expression
  112    112   
        )]
  113         -
        deserializer.read_struct(&COIPADDRESSUSAGE_SCHEMA, (), |_, member, deser| {
         113  +
        deserializer.read_struct(&COIPADDRESSUSAGE_SCHEMA, &mut |member, deser| {
  114    114   
            match member.member_index() {
  115    115   
                Some(0) => {
  116    116   
                    builder.allocation_id = Some(deser.read_string(member)?);
  117    117   
                }
  118    118   
                Some(1) => {
  119    119   
                    builder.aws_account_id = Some(deser.read_string(member)?);
  120    120   
                }
  121    121   
                Some(2) => {
  122    122   
                    builder.aws_service = Some(deser.read_string(member)?);
  123    123   
                }
  124    124   
                Some(3) => {
  125    125   
                    builder.co_ip = Some(deser.read_string(member)?);
  126    126   
                }
  127    127   
                _ => {}
  128    128   
            }
  129    129   
            Ok(())
  130    130   
        })?;
  131    131   
        Ok(builder.build())
  132    132   
    }
  133    133   
}
         134  +
impl CoipAddressUsage {
         135  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         136  +
    pub fn deserialize_with_response(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         138  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         139  +
        _status: u16,
         140  +
        _body: &[u8],
         141  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         142  +
        Self::deserialize(deserializer)
         143  +
    }
         144  +
}
  134    145   
impl CoipAddressUsage {
  135    146   
    /// Creates a new builder-style object to manufacture [`CoipAddressUsage`](crate::types::CoipAddressUsage).
  136    147   
    pub fn builder() -> crate::types::builders::CoipAddressUsageBuilder {
  137    148   
        crate::types::builders::CoipAddressUsageBuilder::default()
  138    149   
    }
  139    150   
}
  140    151   
  141    152   
/// A builder for [`CoipAddressUsage`](crate::types::CoipAddressUsage).
  142    153   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  143    154   
#[non_exhaustive]

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

@@ -3,3 +143,154 @@
   23     23   
    /// <p>The ID of the local gateway route table.</p>
   24     24   
    pub fn local_gateway_route_table_id(&self) -> ::std::option::Option<&str> {
   25     25   
        self.local_gateway_route_table_id.as_deref()
   26     26   
    }
   27     27   
}
   28     28   
static COIPCIDR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   29     29   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipCidr", "com.amazonaws.ec2", "CoipCidr");
   30     30   
static COIPCIDR_MEMBER_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipCidr$Cidr", "com.amazonaws.ec2", "CoipCidr"),
   32     32   
    ::aws_smithy_schema::ShapeType::String,
   33         -
    "cidr",
          33  +
    "Cidr",
   34     34   
    0,
   35     35   
)
   36     36   
.with_xml_name("cidr");
   37     37   
static COIPCIDR_MEMBER_COIP_POOL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipCidr$CoipPoolId", "com.amazonaws.ec2", "CoipCidr"),
   39     39   
    ::aws_smithy_schema::ShapeType::String,
   40         -
    "coip_pool_id",
          40  +
    "CoipPoolId",
   41     41   
    1,
   42     42   
)
   43     43   
.with_xml_name("coipPoolId");
   44     44   
static COIPCIDR_MEMBER_LOCAL_GATEWAY_ROUTE_TABLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipCidr$LocalGatewayRouteTableId", "com.amazonaws.ec2", "CoipCidr"),
   46     46   
    ::aws_smithy_schema::ShapeType::String,
   47         -
    "local_gateway_route_table_id",
          47  +
    "LocalGatewayRouteTableId",
   48     48   
    2,
   49     49   
)
   50     50   
.with_xml_name("localGatewayRouteTableId");
   51     51   
static COIPCIDR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   52     52   
    COIPCIDR_SCHEMA_ID,
   53     53   
    ::aws_smithy_schema::ShapeType::Structure,
   54     54   
    &[
   55     55   
        &COIPCIDR_MEMBER_CIDR,
   56     56   
        &COIPCIDR_MEMBER_COIP_POOL_ID,
   57     57   
        &COIPCIDR_MEMBER_LOCAL_GATEWAY_ROUTE_TABLE_ID,
   58     58   
    ],
   59     59   
);
   60     60   
impl CoipCidr {
   61     61   
    /// The schema for this shape.
   62     62   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COIPCIDR_SCHEMA;
   63     63   
}
   64     64   
impl ::aws_smithy_schema::serde::SerializableStruct for CoipCidr {
   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.cidr {
   71     71   
            ser.write_string(&COIPCIDR_MEMBER_CIDR, val)?;
   72     72   
        }
   73     73   
        if let Some(ref val) = self.coip_pool_id {
   74     74   
            ser.write_string(&COIPCIDR_MEMBER_COIP_POOL_ID, val)?;
   75     75   
        }
   76     76   
        if let Some(ref val) = self.local_gateway_route_table_id {
   77     77   
            ser.write_string(&COIPCIDR_MEMBER_LOCAL_GATEWAY_ROUTE_TABLE_ID, val)?;
   78     78   
        }
   79     79   
        Ok(())
   80     80   
    }
   81     81   
}
   82     82   
impl CoipCidr {
   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(&COIPCIDR_SCHEMA, (), |_, member, deser| {
          96  +
        deserializer.read_struct(&COIPCIDR_SCHEMA, &mut |member, deser| {
   97     97   
            match member.member_index() {
   98     98   
                Some(0) => {
   99     99   
                    builder.cidr = Some(deser.read_string(member)?);
  100    100   
                }
  101    101   
                Some(1) => {
  102    102   
                    builder.coip_pool_id = Some(deser.read_string(member)?);
  103    103   
                }
  104    104   
                Some(2) => {
  105    105   
                    builder.local_gateway_route_table_id = 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 CoipCidr {
         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 CoipCidr {
  115    126   
    /// Creates a new builder-style object to manufacture [`CoipCidr`](crate::types::CoipCidr).
  116    127   
    pub fn builder() -> crate::types::builders::CoipCidrBuilder {
  117    128   
        crate::types::builders::CoipCidrBuilder::default()
  118    129   
    }
  119    130   
}
  120    131   
  121    132   
/// A builder for [`CoipCidr`](crate::types::CoipCidr).
  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/_coip_pool.rs

@@ -19,19 +220,218 @@
   39     39   
    /// <p>The ARN of the address pool.</p>
   40     40   
    pub fn pool_arn(&self) -> ::std::option::Option<&str> {
   41     41   
        self.pool_arn.as_deref()
   42     42   
    }
   43     43   
}
   44     44   
static COIPPOOL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   45     45   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipPool", "com.amazonaws.ec2", "CoipPool");
   46     46   
static COIPPOOL_MEMBER_POOL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipPool$PoolId", "com.amazonaws.ec2", "CoipPool"),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "pool_id",
          49  +
    "PoolId",
   50     50   
    0,
   51     51   
)
   52     52   
.with_xml_name("poolId");
   53     53   
static COIPPOOL_MEMBER_POOL_CIDRS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipPool$PoolCidrs", "com.amazonaws.ec2", "CoipPool"),
   55     55   
    ::aws_smithy_schema::ShapeType::List,
   56         -
    "pool_cidrs",
          56  +
    "PoolCidrs",
   57     57   
    1,
   58     58   
)
   59     59   
.with_xml_name("poolCidrSet");
   60     60   
static COIPPOOL_MEMBER_LOCAL_GATEWAY_ROUTE_TABLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipPool$LocalGatewayRouteTableId", "com.amazonaws.ec2", "CoipPool"),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "local_gateway_route_table_id",
          63  +
    "LocalGatewayRouteTableId",
   64     64   
    2,
   65     65   
)
   66     66   
.with_xml_name("localGatewayRouteTableId");
   67     67   
static COIPPOOL_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipPool$Tags", "com.amazonaws.ec2", "CoipPool"),
   69     69   
    ::aws_smithy_schema::ShapeType::List,
   70         -
    "tags",
          70  +
    "Tags",
   71     71   
    3,
   72     72   
)
   73     73   
.with_xml_name("tagSet");
   74     74   
static COIPPOOL_MEMBER_POOL_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CoipPool$PoolArn", "com.amazonaws.ec2", "CoipPool"),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "pool_arn",
          77  +
    "PoolArn",
   78     78   
    4,
   79     79   
)
   80     80   
.with_xml_name("poolArn");
   81     81   
static COIPPOOL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   82     82   
    COIPPOOL_SCHEMA_ID,
   83     83   
    ::aws_smithy_schema::ShapeType::Structure,
   84     84   
    &[
   85     85   
        &COIPPOOL_MEMBER_POOL_ID,
   86     86   
        &COIPPOOL_MEMBER_POOL_CIDRS,
   87     87   
        &COIPPOOL_MEMBER_LOCAL_GATEWAY_ROUTE_TABLE_ID,
   88     88   
        &COIPPOOL_MEMBER_TAGS,
   89     89   
        &COIPPOOL_MEMBER_POOL_ARN,
   90     90   
    ],
   91     91   
);
   92     92   
impl CoipPool {
   93     93   
    /// The schema for this shape.
   94     94   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COIPPOOL_SCHEMA;
   95     95   
}
   96     96   
impl ::aws_smithy_schema::serde::SerializableStruct for CoipPool {
   97     97   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   98     98   
    fn serialize_members(
   99     99   
        &self,
  100    100   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  101    101   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  102    102   
        if let Some(ref val) = self.pool_id {
  103    103   
            ser.write_string(&COIPPOOL_MEMBER_POOL_ID, val)?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.pool_cidrs {
  106    106   
            ser.write_list(
  107    107   
                &COIPPOOL_MEMBER_POOL_CIDRS,
  108    108   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  109    109   
                    for item in val {
  110    110   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  111    111   
                    }
  112    112   
                    Ok(())
  113    113   
                },
  114    114   
            )?;
  115    115   
        }
  116    116   
        if let Some(ref val) = self.local_gateway_route_table_id {
  117    117   
            ser.write_string(&COIPPOOL_MEMBER_LOCAL_GATEWAY_ROUTE_TABLE_ID, val)?;
  118    118   
        }
  119    119   
        if let Some(ref val) = self.tags {
  120    120   
            ser.write_list(&COIPPOOL_MEMBER_TAGS, &|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   
        if let Some(ref val) = self.pool_arn {
  128    128   
            ser.write_string(&COIPPOOL_MEMBER_POOL_ARN, val)?;
  129    129   
        }
  130    130   
        Ok(())
  131    131   
    }
  132    132   
}
  133    133   
impl CoipPool {
  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(&COIPPOOL_SCHEMA, (), |_, member, deser| {
         147  +
        deserializer.read_struct(&COIPPOOL_SCHEMA, &mut |member, deser| {
  148    148   
            match member.member_index() {
  149    149   
                Some(0) => {
  150    150   
                    builder.pool_id = Some(deser.read_string(member)?);
  151    151   
                }
  152    152   
                Some(1) => {
  153         -
                    builder.pool_cidrs = Some({
  154         -
                        let container = if let Some(cap) = deser.container_size() {
  155         -
                            Vec::with_capacity(cap)
  156         -
                        } else {
  157         -
                            Vec::new()
  158         -
                        };
  159         -
                        deser.read_list(member, container, |mut list, deser| {
  160         -
                            list.push(deser.read_string(member)?);
  161         -
                            Ok(list)
  162         -
                        })?
  163         -
                    });
         153  +
                    builder.pool_cidrs = Some(deser.read_string_list(member)?);
  164    154   
                }
  165    155   
                Some(2) => {
  166    156   
                    builder.local_gateway_route_table_id = Some(deser.read_string(member)?);
  167    157   
                }
  168    158   
                Some(3) => {
  169    159   
                    builder.tags = Some({
  170         -
                        let container = if let Some(cap) = deser.container_size() {
  171         -
                            Vec::with_capacity(cap)
  172         -
                        } else {
  173         -
                            Vec::new()
  174         -
                        };
  175         -
                        deser.read_list(member, container, |mut list, deser| {
  176         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  177         -
                            Ok(list)
  178         -
                        })?
         160  +
                        let mut container = Vec::new();
         161  +
                        deser.read_list(member, &mut |deser| {
         162  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         163  +
                            Ok(())
         164  +
                        })?;
         165  +
                        container
  179    166   
                    });
  180    167   
                }
  181    168   
                Some(4) => {
  182    169   
                    builder.pool_arn = Some(deser.read_string(member)?);
  183    170   
                }
  184    171   
                _ => {}
  185    172   
            }
  186    173   
            Ok(())
  187    174   
        })?;
  188    175   
        Ok(builder.build())
  189    176   
    }
  190    177   
}
         178  +
impl CoipPool {
         179  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         180  +
    pub fn deserialize_with_response(
         181  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         182  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         183  +
        _status: u16,
         184  +
        _body: &[u8],
         185  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         186  +
        Self::deserialize(deserializer)
         187  +
    }
         188  +
}
  191    189   
impl CoipPool {
  192    190   
    /// Creates a new builder-style object to manufacture [`CoipPool`](crate::types::CoipPool).
  193    191   
    pub fn builder() -> crate::types::builders::CoipPoolBuilder {
  194    192   
        crate::types::builders::CoipPoolBuilder::default()
  195    193   
    }
  196    194   
}
  197    195   
  198    196   
/// A builder for [`CoipPool`](crate::types::CoipPool).
  199    197   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  200    198   
#[non_exhaustive]

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

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

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

@@ -10,10 +155,166 @@
   30     30   
    "com.amazonaws.ec2",
   31     31   
    "ConnectionLogResponseOptions",
   32     32   
);
   33     33   
static CONNECTIONLOGRESPONSEOPTIONS_MEMBER_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.ec2#ConnectionLogResponseOptions$Enabled",
   36     36   
        "com.amazonaws.ec2",
   37     37   
        "ConnectionLogResponseOptions",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Boolean,
   40         -
    "enabled",
          40  +
    "Enabled",
   41     41   
    0,
   42     42   
);
   43     43   
static CONNECTIONLOGRESPONSEOPTIONS_MEMBER_CLOUDWATCH_LOG_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.ec2#ConnectionLogResponseOptions$CloudwatchLogGroup",
   46     46   
        "com.amazonaws.ec2",
   47     47   
        "ConnectionLogResponseOptions",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "cloudwatch_log_group",
          50  +
    "CloudwatchLogGroup",
   51     51   
    1,
   52     52   
);
   53     53   
static CONNECTIONLOGRESPONSEOPTIONS_MEMBER_CLOUDWATCH_LOG_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.ec2#ConnectionLogResponseOptions$CloudwatchLogStream",
   56     56   
        "com.amazonaws.ec2",
   57     57   
        "ConnectionLogResponseOptions",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "cloudwatch_log_stream",
          60  +
    "CloudwatchLogStream",
   61     61   
    2,
   62     62   
);
   63     63   
static CONNECTIONLOGRESPONSEOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    CONNECTIONLOGRESPONSEOPTIONS_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &CONNECTIONLOGRESPONSEOPTIONS_MEMBER_ENABLED,
   68     68   
        &CONNECTIONLOGRESPONSEOPTIONS_MEMBER_CLOUDWATCH_LOG_GROUP,
   69     69   
        &CONNECTIONLOGRESPONSEOPTIONS_MEMBER_CLOUDWATCH_LOG_STREAM,
   70     70   
    ],
   71     71   
);
   72     72   
impl ConnectionLogResponseOptions {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONNECTIONLOGRESPONSEOPTIONS_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for ConnectionLogResponseOptions {
   77     77   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   78     78   
    fn serialize_members(
   79     79   
        &self,
   80     80   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   81     81   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   82     82   
        if let Some(ref val) = self.enabled {
   83     83   
            ser.write_boolean(&CONNECTIONLOGRESPONSEOPTIONS_MEMBER_ENABLED, *val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.cloudwatch_log_group {
   86     86   
            ser.write_string(&CONNECTIONLOGRESPONSEOPTIONS_MEMBER_CLOUDWATCH_LOG_GROUP, val)?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.cloudwatch_log_stream {
   89     89   
            ser.write_string(&CONNECTIONLOGRESPONSEOPTIONS_MEMBER_CLOUDWATCH_LOG_STREAM, val)?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl ConnectionLogResponseOptions {
   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(&CONNECTIONLOGRESPONSEOPTIONS_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&CONNECTIONLOGRESPONSEOPTIONS_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.enabled = Some(deser.read_boolean(member)?);
  112    112   
                }
  113    113   
                Some(1) => {
  114    114   
                    builder.cloudwatch_log_group = Some(deser.read_string(member)?);
  115    115   
                }
  116    116   
                Some(2) => {
  117    117   
                    builder.cloudwatch_log_stream = Some(deser.read_string(member)?);
  118    118   
                }
  119    119   
                _ => {}
  120    120   
            }
  121    121   
            Ok(())
  122    122   
        })?;
  123    123   
        Ok(builder.build())
  124    124   
    }
  125    125   
}
         126  +
impl ConnectionLogResponseOptions {
         127  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         128  +
    pub fn deserialize_with_response(
         129  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         130  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         131  +
        _status: u16,
         132  +
        _body: &[u8],
         133  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         134  +
        Self::deserialize(deserializer)
         135  +
    }
         136  +
}
  126    137   
impl ConnectionLogResponseOptions {
  127    138   
    /// Creates a new builder-style object to manufacture [`ConnectionLogResponseOptions`](crate::types::ConnectionLogResponseOptions).
  128    139   
    pub fn builder() -> crate::types::builders::ConnectionLogResponseOptionsBuilder {
  129    140   
        crate::types::builders::ConnectionLogResponseOptionsBuilder::default()
  130    141   
    }
  131    142   
}
  132    143   
  133    144   
/// A builder for [`ConnectionLogResponseOptions`](crate::types::ConnectionLogResponseOptions).
  134    145   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  135    146   
#[non_exhaustive]

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

@@ -39,39 +176,176 @@
   59     59   
}
   60     60   
static CONNECTIONNOTIFICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ConnectionNotification", "com.amazonaws.ec2", "ConnectionNotification");
   62     62   
static CONNECTIONNOTIFICATION_MEMBER_CONNECTION_NOTIFICATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.ec2#ConnectionNotification$ConnectionNotificationId",
   65     65   
        "com.amazonaws.ec2",
   66     66   
        "ConnectionNotification",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "connection_notification_id",
          69  +
    "ConnectionNotificationId",
   70     70   
    0,
   71     71   
)
   72     72   
.with_xml_name("connectionNotificationId");
   73     73   
static CONNECTIONNOTIFICATION_MEMBER_SERVICE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.ec2#ConnectionNotification$ServiceId",
   76     76   
        "com.amazonaws.ec2",
   77     77   
        "ConnectionNotification",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "service_id",
          80  +
    "ServiceId",
   81     81   
    1,
   82     82   
)
   83     83   
.with_xml_name("serviceId");
   84     84   
static CONNECTIONNOTIFICATION_MEMBER_VPC_ENDPOINT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "com.amazonaws.ec2#ConnectionNotification$VpcEndpointId",
   87     87   
        "com.amazonaws.ec2",
   88     88   
        "ConnectionNotification",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::String,
   91         -
    "vpc_endpoint_id",
          91  +
    "VpcEndpointId",
   92     92   
    2,
   93     93   
)
   94     94   
.with_xml_name("vpcEndpointId");
   95     95   
static CONNECTIONNOTIFICATION_MEMBER_CONNECTION_NOTIFICATION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.ec2#ConnectionNotification$ConnectionNotificationType",
   98     98   
        "com.amazonaws.ec2",
   99     99   
        "ConnectionNotification",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::String,
  102         -
    "connection_notification_type",
         102  +
    "ConnectionNotificationType",
  103    103   
    3,
  104    104   
)
  105    105   
.with_xml_name("connectionNotificationType");
  106    106   
static CONNECTIONNOTIFICATION_MEMBER_CONNECTION_NOTIFICATION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.ec2#ConnectionNotification$ConnectionNotificationArn",
  109    109   
        "com.amazonaws.ec2",
  110    110   
        "ConnectionNotification",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::String,
  113         -
    "connection_notification_arn",
         113  +
    "ConnectionNotificationArn",
  114    114   
    4,
  115    115   
)
  116    116   
.with_xml_name("connectionNotificationArn");
  117    117   
static CONNECTIONNOTIFICATION_MEMBER_CONNECTION_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.ec2#ConnectionNotification$ConnectionEvents",
  120    120   
        "com.amazonaws.ec2",
  121    121   
        "ConnectionNotification",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::List,
  124         -
    "connection_events",
         124  +
    "ConnectionEvents",
  125    125   
    5,
  126    126   
)
  127    127   
.with_xml_name("connectionEvents");
  128    128   
static CONNECTIONNOTIFICATION_MEMBER_CONNECTION_NOTIFICATION_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static(
  130    130   
        "com.amazonaws.ec2#ConnectionNotification$ConnectionNotificationState",
  131    131   
        "com.amazonaws.ec2",
  132    132   
        "ConnectionNotification",
  133    133   
    ),
  134    134   
    ::aws_smithy_schema::ShapeType::String,
  135         -
    "connection_notification_state",
         135  +
    "ConnectionNotificationState",
  136    136   
    6,
  137    137   
)
  138    138   
.with_xml_name("connectionNotificationState");
  139    139   
static CONNECTIONNOTIFICATION_MEMBER_SERVICE_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static(
  141    141   
        "com.amazonaws.ec2#ConnectionNotification$ServiceRegion",
  142    142   
        "com.amazonaws.ec2",
  143    143   
        "ConnectionNotification",
  144    144   
    ),
  145    145   
    ::aws_smithy_schema::ShapeType::String,
  146         -
    "service_region",
         146  +
    "ServiceRegion",
  147    147   
    7,
  148    148   
)
  149    149   
.with_xml_name("serviceRegion");
  150    150   
static CONNECTIONNOTIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  151    151   
    CONNECTIONNOTIFICATION_SCHEMA_ID,
  152    152   
    ::aws_smithy_schema::ShapeType::Structure,
  153    153   
    &[
  154    154   
        &CONNECTIONNOTIFICATION_MEMBER_CONNECTION_NOTIFICATION_ID,
  155    155   
        &CONNECTIONNOTIFICATION_MEMBER_SERVICE_ID,
  156    156   
        &CONNECTIONNOTIFICATION_MEMBER_VPC_ENDPOINT_ID,
@@ -181,181 +296,297 @@
  201    201   
            ser.write_string(&CONNECTIONNOTIFICATION_MEMBER_CONNECTION_NOTIFICATION_STATE, val.as_str())?;
  202    202   
        }
  203    203   
        if let Some(ref val) = self.service_region {
  204    204   
            ser.write_string(&CONNECTIONNOTIFICATION_MEMBER_SERVICE_REGION, val)?;
  205    205   
        }
  206    206   
        Ok(())
  207    207   
    }
  208    208   
}
  209    209   
impl ConnectionNotification {
  210    210   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  211         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  212         -
        deserializer: &mut D,
         211  +
    pub fn deserialize(
         212  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  213    213   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  214    214   
        #[allow(unused_variables, unused_mut)]
  215    215   
        let mut builder = Self::builder();
  216    216   
        #[allow(
  217    217   
            unused_variables,
  218    218   
            unreachable_code,
  219    219   
            clippy::single_match,
  220    220   
            clippy::match_single_binding,
  221    221   
            clippy::diverging_sub_expression
  222    222   
        )]
  223         -
        deserializer.read_struct(&CONNECTIONNOTIFICATION_SCHEMA, (), |_, member, deser| {
         223  +
        deserializer.read_struct(&CONNECTIONNOTIFICATION_SCHEMA, &mut |member, deser| {
  224    224   
            match member.member_index() {
  225    225   
                Some(0) => {
  226    226   
                    builder.connection_notification_id = Some(deser.read_string(member)?);
  227    227   
                }
  228    228   
                Some(1) => {
  229    229   
                    builder.service_id = Some(deser.read_string(member)?);
  230    230   
                }
  231    231   
                Some(2) => {
  232    232   
                    builder.vpc_endpoint_id = Some(deser.read_string(member)?);
  233    233   
                }
  234    234   
                Some(3) => {
  235    235   
                    builder.connection_notification_type = Some(crate::types::ConnectionNotificationType::from(deser.read_string(member)?.as_str()));
  236    236   
                }
  237    237   
                Some(4) => {
  238    238   
                    builder.connection_notification_arn = Some(deser.read_string(member)?);
  239    239   
                }
  240    240   
                Some(5) => {
  241         -
                    builder.connection_events = Some({
  242         -
                        let container = if let Some(cap) = deser.container_size() {
  243         -
                            Vec::with_capacity(cap)
  244         -
                        } else {
  245         -
                            Vec::new()
  246         -
                        };
  247         -
                        deser.read_list(member, container, |mut list, deser| {
  248         -
                            list.push(deser.read_string(member)?);
  249         -
                            Ok(list)
  250         -
                        })?
  251         -
                    });
         241  +
                    builder.connection_events = Some(deser.read_string_list(member)?);
  252    242   
                }
  253    243   
                Some(6) => {
  254    244   
                    builder.connection_notification_state =
  255    245   
                        Some(crate::types::ConnectionNotificationState::from(deser.read_string(member)?.as_str()));
  256    246   
                }
  257    247   
                Some(7) => {
  258    248   
                    builder.service_region = Some(deser.read_string(member)?);
  259    249   
                }
  260    250   
                _ => {}
  261    251   
            }
  262    252   
            Ok(())
  263    253   
        })?;
  264    254   
        Ok(builder.build())
  265    255   
    }
  266    256   
}
         257  +
impl ConnectionNotification {
         258  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         259  +
    pub fn deserialize_with_response(
         260  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         261  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         262  +
        _status: u16,
         263  +
        _body: &[u8],
         264  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         265  +
        Self::deserialize(deserializer)
         266  +
    }
         267  +
}
  267    268   
impl ConnectionNotification {
  268    269   
    /// Creates a new builder-style object to manufacture [`ConnectionNotification`](crate::types::ConnectionNotification).
  269    270   
    pub fn builder() -> crate::types::builders::ConnectionNotificationBuilder {
  270    271   
        crate::types::builders::ConnectionNotificationBuilder::default()
  271    272   
    }
  272    273   
}
  273    274   
  274    275   
/// A builder for [`ConnectionNotification`](crate::types::ConnectionNotification).
  275    276   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  276    277   
#[non_exhaustive]

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

@@ -10,10 +158,169 @@
   30     30   
    "com.amazonaws.ec2",
   31     31   
    "ConnectionTrackingConfiguration",
   32     32   
);
   33     33   
static CONNECTIONTRACKINGCONFIGURATION_MEMBER_TCP_ESTABLISHED_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.ec2#ConnectionTrackingConfiguration$TcpEstablishedTimeout",
   36     36   
        "com.amazonaws.ec2",
   37     37   
        "ConnectionTrackingConfiguration",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Integer,
   40         -
    "tcp_established_timeout",
          40  +
    "TcpEstablishedTimeout",
   41     41   
    0,
   42     42   
)
   43     43   
.with_xml_name("tcpEstablishedTimeout");
   44     44   
static CONNECTIONTRACKINGCONFIGURATION_MEMBER_UDP_STREAM_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static(
   46     46   
        "com.amazonaws.ec2#ConnectionTrackingConfiguration$UdpStreamTimeout",
   47     47   
        "com.amazonaws.ec2",
   48     48   
        "ConnectionTrackingConfiguration",
   49     49   
    ),
   50     50   
    ::aws_smithy_schema::ShapeType::Integer,
   51         -
    "udp_stream_timeout",
          51  +
    "UdpStreamTimeout",
   52     52   
    1,
   53     53   
)
   54     54   
.with_xml_name("udpStreamTimeout");
   55     55   
static CONNECTIONTRACKINGCONFIGURATION_MEMBER_UDP_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.ec2#ConnectionTrackingConfiguration$UdpTimeout",
   58     58   
        "com.amazonaws.ec2",
   59     59   
        "ConnectionTrackingConfiguration",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::Integer,
   62         -
    "udp_timeout",
          62  +
    "UdpTimeout",
   63     63   
    2,
   64     64   
)
   65     65   
.with_xml_name("udpTimeout");
   66     66   
static CONNECTIONTRACKINGCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   67     67   
    CONNECTIONTRACKINGCONFIGURATION_SCHEMA_ID,
   68     68   
    ::aws_smithy_schema::ShapeType::Structure,
   69     69   
    &[
   70     70   
        &CONNECTIONTRACKINGCONFIGURATION_MEMBER_TCP_ESTABLISHED_TIMEOUT,
   71     71   
        &CONNECTIONTRACKINGCONFIGURATION_MEMBER_UDP_STREAM_TIMEOUT,
   72     72   
        &CONNECTIONTRACKINGCONFIGURATION_MEMBER_UDP_TIMEOUT,
   73     73   
    ],
   74     74   
);
   75     75   
impl ConnectionTrackingConfiguration {
   76     76   
    /// The schema for this shape.
   77     77   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONNECTIONTRACKINGCONFIGURATION_SCHEMA;
   78     78   
}
   79     79   
impl ::aws_smithy_schema::serde::SerializableStruct for ConnectionTrackingConfiguration {
   80     80   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   81     81   
    fn serialize_members(
   82     82   
        &self,
   83     83   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   84     84   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   85     85   
        if let Some(ref val) = self.tcp_established_timeout {
   86     86   
            ser.write_integer(&CONNECTIONTRACKINGCONFIGURATION_MEMBER_TCP_ESTABLISHED_TIMEOUT, *val)?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.udp_stream_timeout {
   89     89   
            ser.write_integer(&CONNECTIONTRACKINGCONFIGURATION_MEMBER_UDP_STREAM_TIMEOUT, *val)?;
   90     90   
        }
   91     91   
        if let Some(ref val) = self.udp_timeout {
   92     92   
            ser.write_integer(&CONNECTIONTRACKINGCONFIGURATION_MEMBER_UDP_TIMEOUT, *val)?;
   93     93   
        }
   94     94   
        Ok(())
   95     95   
    }
   96     96   
}
   97     97   
impl ConnectionTrackingConfiguration {
   98     98   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   99         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  100         -
        deserializer: &mut D,
          99  +
    pub fn deserialize(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  101    101   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  102    102   
        #[allow(unused_variables, unused_mut)]
  103    103   
        let mut builder = Self::builder();
  104    104   
        #[allow(
  105    105   
            unused_variables,
  106    106   
            unreachable_code,
  107    107   
            clippy::single_match,
  108    108   
            clippy::match_single_binding,
  109    109   
            clippy::diverging_sub_expression
  110    110   
        )]
  111         -
        deserializer.read_struct(&CONNECTIONTRACKINGCONFIGURATION_SCHEMA, (), |_, member, deser| {
         111  +
        deserializer.read_struct(&CONNECTIONTRACKINGCONFIGURATION_SCHEMA, &mut |member, deser| {
  112    112   
            match member.member_index() {
  113    113   
                Some(0) => {
  114    114   
                    builder.tcp_established_timeout = Some(deser.read_integer(member)?);
  115    115   
                }
  116    116   
                Some(1) => {
  117    117   
                    builder.udp_stream_timeout = Some(deser.read_integer(member)?);
  118    118   
                }
  119    119   
                Some(2) => {
  120    120   
                    builder.udp_timeout = Some(deser.read_integer(member)?);
  121    121   
                }
  122    122   
                _ => {}
  123    123   
            }
  124    124   
            Ok(())
  125    125   
        })?;
  126    126   
        Ok(builder.build())
  127    127   
    }
  128    128   
}
         129  +
impl ConnectionTrackingConfiguration {
         130  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         131  +
    pub fn deserialize_with_response(
         132  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         133  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         134  +
        _status: u16,
         135  +
        _body: &[u8],
         136  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         137  +
        Self::deserialize(deserializer)
         138  +
    }
         139  +
}
  129    140   
impl ConnectionTrackingConfiguration {
  130    141   
    /// Creates a new builder-style object to manufacture [`ConnectionTrackingConfiguration`](crate::types::ConnectionTrackingConfiguration).
  131    142   
    pub fn builder() -> crate::types::builders::ConnectionTrackingConfigurationBuilder {
  132    143   
        crate::types::builders::ConnectionTrackingConfigurationBuilder::default()
  133    144   
    }
  134    145   
}
  135    146   
  136    147   
/// A builder for [`ConnectionTrackingConfiguration`](crate::types::ConnectionTrackingConfiguration).
  137    148   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  138    149   
#[non_exhaustive]

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

@@ -10,10 +158,169 @@
   30     30   
    "com.amazonaws.ec2",
   31     31   
    "ConnectionTrackingSpecification",
   32     32   
);
   33     33   
static CONNECTIONTRACKINGSPECIFICATION_MEMBER_TCP_ESTABLISHED_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.ec2#ConnectionTrackingSpecification$TcpEstablishedTimeout",
   36     36   
        "com.amazonaws.ec2",
   37     37   
        "ConnectionTrackingSpecification",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Integer,
   40         -
    "tcp_established_timeout",
          40  +
    "TcpEstablishedTimeout",
   41     41   
    0,
   42     42   
)
   43     43   
.with_xml_name("tcpEstablishedTimeout");
   44     44   
static CONNECTIONTRACKINGSPECIFICATION_MEMBER_UDP_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static(
   46     46   
        "com.amazonaws.ec2#ConnectionTrackingSpecification$UdpTimeout",
   47     47   
        "com.amazonaws.ec2",
   48     48   
        "ConnectionTrackingSpecification",
   49     49   
    ),
   50     50   
    ::aws_smithy_schema::ShapeType::Integer,
   51         -
    "udp_timeout",
          51  +
    "UdpTimeout",
   52     52   
    1,
   53     53   
)
   54     54   
.with_xml_name("udpTimeout");
   55     55   
static CONNECTIONTRACKINGSPECIFICATION_MEMBER_UDP_STREAM_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.ec2#ConnectionTrackingSpecification$UdpStreamTimeout",
   58     58   
        "com.amazonaws.ec2",
   59     59   
        "ConnectionTrackingSpecification",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::Integer,
   62         -
    "udp_stream_timeout",
          62  +
    "UdpStreamTimeout",
   63     63   
    2,
   64     64   
)
   65     65   
.with_xml_name("udpStreamTimeout");
   66     66   
static CONNECTIONTRACKINGSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   67     67   
    CONNECTIONTRACKINGSPECIFICATION_SCHEMA_ID,
   68     68   
    ::aws_smithy_schema::ShapeType::Structure,
   69     69   
    &[
   70     70   
        &CONNECTIONTRACKINGSPECIFICATION_MEMBER_TCP_ESTABLISHED_TIMEOUT,
   71     71   
        &CONNECTIONTRACKINGSPECIFICATION_MEMBER_UDP_TIMEOUT,
   72     72   
        &CONNECTIONTRACKINGSPECIFICATION_MEMBER_UDP_STREAM_TIMEOUT,
   73     73   
    ],
   74     74   
);
   75     75   
impl ConnectionTrackingSpecification {
   76     76   
    /// The schema for this shape.
   77     77   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONNECTIONTRACKINGSPECIFICATION_SCHEMA;
   78     78   
}
   79     79   
impl ::aws_smithy_schema::serde::SerializableStruct for ConnectionTrackingSpecification {
   80     80   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   81     81   
    fn serialize_members(
   82     82   
        &self,
   83     83   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   84     84   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   85     85   
        if let Some(ref val) = self.tcp_established_timeout {
   86     86   
            ser.write_integer(&CONNECTIONTRACKINGSPECIFICATION_MEMBER_TCP_ESTABLISHED_TIMEOUT, *val)?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.udp_timeout {
   89     89   
            ser.write_integer(&CONNECTIONTRACKINGSPECIFICATION_MEMBER_UDP_TIMEOUT, *val)?;
   90     90   
        }
   91     91   
        if let Some(ref val) = self.udp_stream_timeout {
   92     92   
            ser.write_integer(&CONNECTIONTRACKINGSPECIFICATION_MEMBER_UDP_STREAM_TIMEOUT, *val)?;
   93     93   
        }
   94     94   
        Ok(())
   95     95   
    }
   96     96   
}
   97     97   
impl ConnectionTrackingSpecification {
   98     98   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   99         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  100         -
        deserializer: &mut D,
          99  +
    pub fn deserialize(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  101    101   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  102    102   
        #[allow(unused_variables, unused_mut)]
  103    103   
        let mut builder = Self::builder();
  104    104   
        #[allow(
  105    105   
            unused_variables,
  106    106   
            unreachable_code,
  107    107   
            clippy::single_match,
  108    108   
            clippy::match_single_binding,
  109    109   
            clippy::diverging_sub_expression
  110    110   
        )]
  111         -
        deserializer.read_struct(&CONNECTIONTRACKINGSPECIFICATION_SCHEMA, (), |_, member, deser| {
         111  +
        deserializer.read_struct(&CONNECTIONTRACKINGSPECIFICATION_SCHEMA, &mut |member, deser| {
  112    112   
            match member.member_index() {
  113    113   
                Some(0) => {
  114    114   
                    builder.tcp_established_timeout = Some(deser.read_integer(member)?);
  115    115   
                }
  116    116   
                Some(1) => {
  117    117   
                    builder.udp_timeout = Some(deser.read_integer(member)?);
  118    118   
                }
  119    119   
                Some(2) => {
  120    120   
                    builder.udp_stream_timeout = Some(deser.read_integer(member)?);
  121    121   
                }
  122    122   
                _ => {}
  123    123   
            }
  124    124   
            Ok(())
  125    125   
        })?;
  126    126   
        Ok(builder.build())
  127    127   
    }
  128    128   
}
         129  +
impl ConnectionTrackingSpecification {
         130  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         131  +
    pub fn deserialize_with_response(
         132  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         133  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         134  +
        _status: u16,
         135  +
        _body: &[u8],
         136  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         137  +
        Self::deserialize(deserializer)
         138  +
    }
         139  +
}
  129    140   
impl ConnectionTrackingSpecification {
  130    141   
    /// Creates a new builder-style object to manufacture [`ConnectionTrackingSpecification`](crate::types::ConnectionTrackingSpecification).
  131    142   
    pub fn builder() -> crate::types::builders::ConnectionTrackingSpecificationBuilder {
  132    143   
        crate::types::builders::ConnectionTrackingSpecificationBuilder::default()
  133    144   
    }
  134    145   
}
  135    146   
  136    147   
/// A builder for [`ConnectionTrackingSpecification`](crate::types::ConnectionTrackingSpecification).
  137    148   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  138    149   
#[non_exhaustive]

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

@@ -10,10 +155,166 @@
   30     30   
    "com.amazonaws.ec2",
   31     31   
    "ConnectionTrackingSpecificationRequest",
   32     32   
);
   33     33   
static CONNECTIONTRACKINGSPECIFICATIONREQUEST_MEMBER_TCP_ESTABLISHED_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.ec2#ConnectionTrackingSpecificationRequest$TcpEstablishedTimeout",
   36     36   
        "com.amazonaws.ec2",
   37     37   
        "ConnectionTrackingSpecificationRequest",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Integer,
   40         -
    "tcp_established_timeout",
          40  +
    "TcpEstablishedTimeout",
   41     41   
    0,
   42     42   
);
   43     43   
static CONNECTIONTRACKINGSPECIFICATIONREQUEST_MEMBER_UDP_STREAM_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.ec2#ConnectionTrackingSpecificationRequest$UdpStreamTimeout",
   46     46   
        "com.amazonaws.ec2",
   47     47   
        "ConnectionTrackingSpecificationRequest",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::Integer,
   50         -
    "udp_stream_timeout",
          50  +
    "UdpStreamTimeout",
   51     51   
    1,
   52     52   
);
   53     53   
static CONNECTIONTRACKINGSPECIFICATIONREQUEST_MEMBER_UDP_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.ec2#ConnectionTrackingSpecificationRequest$UdpTimeout",
   56     56   
        "com.amazonaws.ec2",
   57     57   
        "ConnectionTrackingSpecificationRequest",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Integer,
   60         -
    "udp_timeout",
          60  +
    "UdpTimeout",
   61     61   
    2,
   62     62   
);
   63     63   
static CONNECTIONTRACKINGSPECIFICATIONREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    CONNECTIONTRACKINGSPECIFICATIONREQUEST_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &CONNECTIONTRACKINGSPECIFICATIONREQUEST_MEMBER_TCP_ESTABLISHED_TIMEOUT,
   68     68   
        &CONNECTIONTRACKINGSPECIFICATIONREQUEST_MEMBER_UDP_STREAM_TIMEOUT,
   69     69   
        &CONNECTIONTRACKINGSPECIFICATIONREQUEST_MEMBER_UDP_TIMEOUT,
   70     70   
    ],
   71     71   
);
   72     72   
impl ConnectionTrackingSpecificationRequest {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONNECTIONTRACKINGSPECIFICATIONREQUEST_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for ConnectionTrackingSpecificationRequest {
   77     77   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   78     78   
    fn serialize_members(
   79     79   
        &self,
   80     80   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   81     81   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   82     82   
        if let Some(ref val) = self.tcp_established_timeout {
   83     83   
            ser.write_integer(&CONNECTIONTRACKINGSPECIFICATIONREQUEST_MEMBER_TCP_ESTABLISHED_TIMEOUT, *val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.udp_stream_timeout {
   86     86   
            ser.write_integer(&CONNECTIONTRACKINGSPECIFICATIONREQUEST_MEMBER_UDP_STREAM_TIMEOUT, *val)?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.udp_timeout {
   89     89   
            ser.write_integer(&CONNECTIONTRACKINGSPECIFICATIONREQUEST_MEMBER_UDP_TIMEOUT, *val)?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl ConnectionTrackingSpecificationRequest {
   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(&CONNECTIONTRACKINGSPECIFICATIONREQUEST_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&CONNECTIONTRACKINGSPECIFICATIONREQUEST_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.tcp_established_timeout = Some(deser.read_integer(member)?);
  112    112   
                }
  113    113   
                Some(1) => {
  114    114   
                    builder.udp_stream_timeout = Some(deser.read_integer(member)?);
  115    115   
                }
  116    116   
                Some(2) => {
  117    117   
                    builder.udp_timeout = Some(deser.read_integer(member)?);
  118    118   
                }
  119    119   
                _ => {}
  120    120   
            }
  121    121   
            Ok(())
  122    122   
        })?;
  123    123   
        Ok(builder.build())
  124    124   
    }
  125    125   
}
         126  +
impl ConnectionTrackingSpecificationRequest {
         127  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         128  +
    pub fn deserialize_with_response(
         129  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         130  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         131  +
        _status: u16,
         132  +
        _body: &[u8],
         133  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         134  +
        Self::deserialize(deserializer)
         135  +
    }
         136  +
}
  126    137   
impl ConnectionTrackingSpecificationRequest {
  127    138   
    /// Creates a new builder-style object to manufacture [`ConnectionTrackingSpecificationRequest`](crate::types::ConnectionTrackingSpecificationRequest).
  128    139   
    pub fn builder() -> crate::types::builders::ConnectionTrackingSpecificationRequestBuilder {
  129    140   
        crate::types::builders::ConnectionTrackingSpecificationRequestBuilder::default()
  130    141   
    }
  131    142   
}
  132    143   
  133    144   
/// A builder for [`ConnectionTrackingSpecificationRequest`](crate::types::ConnectionTrackingSpecificationRequest).
  134    145   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  135    146   
#[non_exhaustive]

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

@@ -10,10 +158,169 @@
   30     30   
    "com.amazonaws.ec2",
   31     31   
    "ConnectionTrackingSpecificationResponse",
   32     32   
);
   33     33   
static CONNECTIONTRACKINGSPECIFICATIONRESPONSE_MEMBER_TCP_ESTABLISHED_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.ec2#ConnectionTrackingSpecificationResponse$TcpEstablishedTimeout",
   36     36   
        "com.amazonaws.ec2",
   37     37   
        "ConnectionTrackingSpecificationResponse",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Integer,
   40         -
    "tcp_established_timeout",
          40  +
    "TcpEstablishedTimeout",
   41     41   
    0,
   42     42   
)
   43     43   
.with_xml_name("tcpEstablishedTimeout");
   44     44   
static CONNECTIONTRACKINGSPECIFICATIONRESPONSE_MEMBER_UDP_STREAM_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static(
   46     46   
        "com.amazonaws.ec2#ConnectionTrackingSpecificationResponse$UdpStreamTimeout",
   47     47   
        "com.amazonaws.ec2",
   48     48   
        "ConnectionTrackingSpecificationResponse",
   49     49   
    ),
   50     50   
    ::aws_smithy_schema::ShapeType::Integer,
   51         -
    "udp_stream_timeout",
          51  +
    "UdpStreamTimeout",
   52     52   
    1,
   53     53   
)
   54     54   
.with_xml_name("udpStreamTimeout");
   55     55   
static CONNECTIONTRACKINGSPECIFICATIONRESPONSE_MEMBER_UDP_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.ec2#ConnectionTrackingSpecificationResponse$UdpTimeout",
   58     58   
        "com.amazonaws.ec2",
   59     59   
        "ConnectionTrackingSpecificationResponse",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::Integer,
   62         -
    "udp_timeout",
          62  +
    "UdpTimeout",
   63     63   
    2,
   64     64   
)
   65     65   
.with_xml_name("udpTimeout");
   66     66   
static CONNECTIONTRACKINGSPECIFICATIONRESPONSE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   67     67   
    CONNECTIONTRACKINGSPECIFICATIONRESPONSE_SCHEMA_ID,
   68     68   
    ::aws_smithy_schema::ShapeType::Structure,
   69     69   
    &[
   70     70   
        &CONNECTIONTRACKINGSPECIFICATIONRESPONSE_MEMBER_TCP_ESTABLISHED_TIMEOUT,
   71     71   
        &CONNECTIONTRACKINGSPECIFICATIONRESPONSE_MEMBER_UDP_STREAM_TIMEOUT,
   72     72   
        &CONNECTIONTRACKINGSPECIFICATIONRESPONSE_MEMBER_UDP_TIMEOUT,
   73     73   
    ],
   74     74   
);
   75     75   
impl ConnectionTrackingSpecificationResponse {
   76     76   
    /// The schema for this shape.
   77     77   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONNECTIONTRACKINGSPECIFICATIONRESPONSE_SCHEMA;
   78     78   
}
   79     79   
impl ::aws_smithy_schema::serde::SerializableStruct for ConnectionTrackingSpecificationResponse {
   80     80   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   81     81   
    fn serialize_members(
   82     82   
        &self,
   83     83   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   84     84   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   85     85   
        if let Some(ref val) = self.tcp_established_timeout {
   86     86   
            ser.write_integer(&CONNECTIONTRACKINGSPECIFICATIONRESPONSE_MEMBER_TCP_ESTABLISHED_TIMEOUT, *val)?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.udp_stream_timeout {
   89     89   
            ser.write_integer(&CONNECTIONTRACKINGSPECIFICATIONRESPONSE_MEMBER_UDP_STREAM_TIMEOUT, *val)?;
   90     90   
        }
   91     91   
        if let Some(ref val) = self.udp_timeout {
   92     92   
            ser.write_integer(&CONNECTIONTRACKINGSPECIFICATIONRESPONSE_MEMBER_UDP_TIMEOUT, *val)?;
   93     93   
        }
   94     94   
        Ok(())
   95     95   
    }
   96     96   
}
   97     97   
impl ConnectionTrackingSpecificationResponse {
   98     98   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   99         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  100         -
        deserializer: &mut D,
          99  +
    pub fn deserialize(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  101    101   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  102    102   
        #[allow(unused_variables, unused_mut)]
  103    103   
        let mut builder = Self::builder();
  104    104   
        #[allow(
  105    105   
            unused_variables,
  106    106   
            unreachable_code,
  107    107   
            clippy::single_match,
  108    108   
            clippy::match_single_binding,
  109    109   
            clippy::diverging_sub_expression
  110    110   
        )]
  111         -
        deserializer.read_struct(&CONNECTIONTRACKINGSPECIFICATIONRESPONSE_SCHEMA, (), |_, member, deser| {
         111  +
        deserializer.read_struct(&CONNECTIONTRACKINGSPECIFICATIONRESPONSE_SCHEMA, &mut |member, deser| {
  112    112   
            match member.member_index() {
  113    113   
                Some(0) => {
  114    114   
                    builder.tcp_established_timeout = Some(deser.read_integer(member)?);
  115    115   
                }
  116    116   
                Some(1) => {
  117    117   
                    builder.udp_stream_timeout = Some(deser.read_integer(member)?);
  118    118   
                }
  119    119   
                Some(2) => {
  120    120   
                    builder.udp_timeout = Some(deser.read_integer(member)?);
  121    121   
                }
  122    122   
                _ => {}
  123    123   
            }
  124    124   
            Ok(())
  125    125   
        })?;
  126    126   
        Ok(builder.build())
  127    127   
    }
  128    128   
}
         129  +
impl ConnectionTrackingSpecificationResponse {
         130  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         131  +
    pub fn deserialize_with_response(
         132  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         133  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         134  +
        _status: u16,
         135  +
        _body: &[u8],
         136  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         137  +
        Self::deserialize(deserializer)
         138  +
    }
         139  +
}
  129    140   
impl ConnectionTrackingSpecificationResponse {
  130    141   
    /// Creates a new builder-style object to manufacture [`ConnectionTrackingSpecificationResponse`](crate::types::ConnectionTrackingSpecificationResponse).
  131    142   
    pub fn builder() -> crate::types::builders::ConnectionTrackingSpecificationResponseBuilder {
  132    143   
        crate::types::builders::ConnectionTrackingSpecificationResponseBuilder::default()
  133    144   
    }
  134    145   
}
  135    146   
  136    147   
/// A builder for [`ConnectionTrackingSpecificationResponse`](crate::types::ConnectionTrackingSpecificationResponse).
  137    148   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  138    149   
#[non_exhaustive]

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

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

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

@@ -3,3 +143,154 @@
   23     23   
    /// <p>Indicates whether the instance is enabled for AMD SEV-SNP. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sev-snp.html">AMD SEV-SNP</a>.</p>
   24     24   
    pub fn amd_sev_snp(&self) -> ::std::option::Option<&crate::types::AmdSevSnpSpecification> {
   25     25   
        self.amd_sev_snp.as_ref()
   26     26   
    }
   27     27   
}
   28     28   
static CPUOPTIONS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   29     29   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CpuOptions", "com.amazonaws.ec2", "CpuOptions");
   30     30   
static CPUOPTIONS_MEMBER_CORE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CpuOptions$CoreCount", "com.amazonaws.ec2", "CpuOptions"),
   32     32   
    ::aws_smithy_schema::ShapeType::Integer,
   33         -
    "core_count",
          33  +
    "CoreCount",
   34     34   
    0,
   35     35   
)
   36     36   
.with_xml_name("coreCount");
   37     37   
static CPUOPTIONS_MEMBER_THREADS_PER_CORE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CpuOptions$ThreadsPerCore", "com.amazonaws.ec2", "CpuOptions"),
   39     39   
    ::aws_smithy_schema::ShapeType::Integer,
   40         -
    "threads_per_core",
          40  +
    "ThreadsPerCore",
   41     41   
    1,
   42     42   
)
   43     43   
.with_xml_name("threadsPerCore");
   44     44   
static CPUOPTIONS_MEMBER_AMD_SEV_SNP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CpuOptions$AmdSevSnp", "com.amazonaws.ec2", "CpuOptions"),
   46     46   
    ::aws_smithy_schema::ShapeType::String,
   47         -
    "amd_sev_snp",
          47  +
    "AmdSevSnp",
   48     48   
    2,
   49     49   
)
   50     50   
.with_xml_name("amdSevSnp");
   51     51   
static CPUOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   52     52   
    CPUOPTIONS_SCHEMA_ID,
   53     53   
    ::aws_smithy_schema::ShapeType::Structure,
   54     54   
    &[
   55     55   
        &CPUOPTIONS_MEMBER_CORE_COUNT,
   56     56   
        &CPUOPTIONS_MEMBER_THREADS_PER_CORE,
   57     57   
        &CPUOPTIONS_MEMBER_AMD_SEV_SNP,
   58     58   
    ],
   59     59   
);
   60     60   
impl CpuOptions {
   61     61   
    /// The schema for this shape.
   62     62   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CPUOPTIONS_SCHEMA;
   63     63   
}
   64     64   
impl ::aws_smithy_schema::serde::SerializableStruct for CpuOptions {
   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.core_count {
   71     71   
            ser.write_integer(&CPUOPTIONS_MEMBER_CORE_COUNT, *val)?;
   72     72   
        }
   73     73   
        if let Some(ref val) = self.threads_per_core {
   74     74   
            ser.write_integer(&CPUOPTIONS_MEMBER_THREADS_PER_CORE, *val)?;
   75     75   
        }
   76     76   
        if let Some(ref val) = self.amd_sev_snp {
   77     77   
            ser.write_string(&CPUOPTIONS_MEMBER_AMD_SEV_SNP, val.as_str())?;
   78     78   
        }
   79     79   
        Ok(())
   80     80   
    }
   81     81   
}
   82     82   
impl CpuOptions {
   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(&CPUOPTIONS_SCHEMA, (), |_, member, deser| {
          96  +
        deserializer.read_struct(&CPUOPTIONS_SCHEMA, &mut |member, deser| {
   97     97   
            match member.member_index() {
   98     98   
                Some(0) => {
   99     99   
                    builder.core_count = Some(deser.read_integer(member)?);
  100    100   
                }
  101    101   
                Some(1) => {
  102    102   
                    builder.threads_per_core = Some(deser.read_integer(member)?);
  103    103   
                }
  104    104   
                Some(2) => {
  105    105   
                    builder.amd_sev_snp = Some(crate::types::AmdSevSnpSpecification::from(deser.read_string(member)?.as_str()));
  106    106   
                }
  107    107   
                _ => {}
  108    108   
            }
  109    109   
            Ok(())
  110    110   
        })?;
  111    111   
        Ok(builder.build())
  112    112   
    }
  113    113   
}
         114  +
impl CpuOptions {
         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 CpuOptions {
  115    126   
    /// Creates a new builder-style object to manufacture [`CpuOptions`](crate::types::CpuOptions).
  116    127   
    pub fn builder() -> crate::types::builders::CpuOptionsBuilder {
  117    128   
        crate::types::builders::CpuOptionsBuilder::default()
  118    129   
    }
  119    130   
}
  120    131   
  121    132   
/// A builder for [`CpuOptions`](crate::types::CpuOptions).
  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/_cpu_options_request.rs

@@ -3,3 +144,155 @@
   23     23   
    /// <p>Indicates whether to enable the instance for AMD SEV-SNP. AMD SEV-SNP is supported with M6a, R6a, and C6a instance types only. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sev-snp.html">AMD SEV-SNP</a>.</p>
   24     24   
    pub fn amd_sev_snp(&self) -> ::std::option::Option<&crate::types::AmdSevSnpSpecification> {
   25     25   
        self.amd_sev_snp.as_ref()
   26     26   
    }
   27     27   
}
   28     28   
static CPUOPTIONSREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   29     29   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CpuOptionsRequest", "com.amazonaws.ec2", "CpuOptionsRequest");
   30     30   
static CPUOPTIONSREQUEST_MEMBER_CORE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CpuOptionsRequest$CoreCount", "com.amazonaws.ec2", "CpuOptionsRequest"),
   32     32   
    ::aws_smithy_schema::ShapeType::Integer,
   33         -
    "core_count",
          33  +
    "CoreCount",
   34     34   
    0,
   35     35   
);
   36     36   
static CPUOPTIONSREQUEST_MEMBER_THREADS_PER_CORE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static(
   38     38   
        "com.amazonaws.ec2#CpuOptionsRequest$ThreadsPerCore",
   39     39   
        "com.amazonaws.ec2",
   40     40   
        "CpuOptionsRequest",
   41     41   
    ),
   42     42   
    ::aws_smithy_schema::ShapeType::Integer,
   43         -
    "threads_per_core",
          43  +
    "ThreadsPerCore",
   44     44   
    1,
   45     45   
);
   46     46   
static CPUOPTIONSREQUEST_MEMBER_AMD_SEV_SNP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CpuOptionsRequest$AmdSevSnp", "com.amazonaws.ec2", "CpuOptionsRequest"),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "amd_sev_snp",
          49  +
    "AmdSevSnp",
   50     50   
    2,
   51     51   
);
   52     52   
static CPUOPTIONSREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   53     53   
    CPUOPTIONSREQUEST_SCHEMA_ID,
   54     54   
    ::aws_smithy_schema::ShapeType::Structure,
   55     55   
    &[
   56     56   
        &CPUOPTIONSREQUEST_MEMBER_CORE_COUNT,
   57     57   
        &CPUOPTIONSREQUEST_MEMBER_THREADS_PER_CORE,
   58     58   
        &CPUOPTIONSREQUEST_MEMBER_AMD_SEV_SNP,
   59     59   
    ],
   60     60   
);
   61     61   
impl CpuOptionsRequest {
   62     62   
    /// The schema for this shape.
   63     63   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CPUOPTIONSREQUEST_SCHEMA;
   64     64   
}
   65     65   
impl ::aws_smithy_schema::serde::SerializableStruct for CpuOptionsRequest {
   66     66   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   67     67   
    fn serialize_members(
   68     68   
        &self,
   69     69   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   70     70   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   71     71   
        if let Some(ref val) = self.core_count {
   72     72   
            ser.write_integer(&CPUOPTIONSREQUEST_MEMBER_CORE_COUNT, *val)?;
   73     73   
        }
   74     74   
        if let Some(ref val) = self.threads_per_core {
   75     75   
            ser.write_integer(&CPUOPTIONSREQUEST_MEMBER_THREADS_PER_CORE, *val)?;
   76     76   
        }
   77     77   
        if let Some(ref val) = self.amd_sev_snp {
   78     78   
            ser.write_string(&CPUOPTIONSREQUEST_MEMBER_AMD_SEV_SNP, val.as_str())?;
   79     79   
        }
   80     80   
        Ok(())
   81     81   
    }
   82     82   
}
   83     83   
impl CpuOptionsRequest {
   84     84   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   85         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   86         -
        deserializer: &mut D,
          85  +
    pub fn deserialize(
          86  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   87     87   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   88     88   
        #[allow(unused_variables, unused_mut)]
   89     89   
        let mut builder = Self::builder();
   90     90   
        #[allow(
   91     91   
            unused_variables,
   92     92   
            unreachable_code,
   93     93   
            clippy::single_match,
   94     94   
            clippy::match_single_binding,
   95     95   
            clippy::diverging_sub_expression
   96     96   
        )]
   97         -
        deserializer.read_struct(&CPUOPTIONSREQUEST_SCHEMA, (), |_, member, deser| {
          97  +
        deserializer.read_struct(&CPUOPTIONSREQUEST_SCHEMA, &mut |member, deser| {
   98     98   
            match member.member_index() {
   99     99   
                Some(0) => {
  100    100   
                    builder.core_count = Some(deser.read_integer(member)?);
  101    101   
                }
  102    102   
                Some(1) => {
  103    103   
                    builder.threads_per_core = Some(deser.read_integer(member)?);
  104    104   
                }
  105    105   
                Some(2) => {
  106    106   
                    builder.amd_sev_snp = Some(crate::types::AmdSevSnpSpecification::from(deser.read_string(member)?.as_str()));
  107    107   
                }
  108    108   
                _ => {}
  109    109   
            }
  110    110   
            Ok(())
  111    111   
        })?;
  112    112   
        Ok(builder.build())
  113    113   
    }
  114    114   
}
         115  +
impl CpuOptionsRequest {
         116  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         117  +
    pub fn deserialize_with_response(
         118  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         119  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         120  +
        _status: u16,
         121  +
        _body: &[u8],
         122  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         123  +
        Self::deserialize(deserializer)
         124  +
    }
         125  +
}
  115    126   
impl CpuOptionsRequest {
  116    127   
    /// Creates a new builder-style object to manufacture [`CpuOptionsRequest`](crate::types::CpuOptionsRequest).
  117    128   
    pub fn builder() -> crate::types::builders::CpuOptionsRequestBuilder {
  118    129   
        crate::types::builders::CpuOptionsRequestBuilder::default()
  119    130   
    }
  120    131   
}
  121    132   
  122    133   
/// A builder for [`CpuOptionsRequest`](crate::types::CpuOptionsRequest).
  123    134   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  124    135   
#[non_exhaustive]

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

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