AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12

Files changed:

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

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

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

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

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

@@ -54,54 +274,285 @@
   74     74   
    "com.amazonaws.ec2",
   75     75   
    "LaunchTemplateOverrides",
   76     76   
);
   77     77   
static LAUNCHTEMPLATEOVERRIDES_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.ec2#LaunchTemplateOverrides$InstanceType",
   80     80   
        "com.amazonaws.ec2",
   81     81   
        "LaunchTemplateOverrides",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "instance_type",
          84  +
    "InstanceType",
   85     85   
    0,
   86     86   
)
   87     87   
.with_xml_name("instanceType");
   88     88   
static LAUNCHTEMPLATEOVERRIDES_MEMBER_SPOT_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.ec2#LaunchTemplateOverrides$SpotPrice",
   91     91   
        "com.amazonaws.ec2",
   92     92   
        "LaunchTemplateOverrides",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::String,
   95         -
    "spot_price",
          95  +
    "SpotPrice",
   96     96   
    1,
   97     97   
)
   98     98   
.with_xml_name("spotPrice");
   99     99   
static LAUNCHTEMPLATEOVERRIDES_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.ec2#LaunchTemplateOverrides$SubnetId",
  102    102   
        "com.amazonaws.ec2",
  103    103   
        "LaunchTemplateOverrides",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::String,
  106         -
    "subnet_id",
         106  +
    "SubnetId",
  107    107   
    2,
  108    108   
)
  109    109   
.with_xml_name("subnetId");
  110    110   
static LAUNCHTEMPLATEOVERRIDES_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static(
  112    112   
        "com.amazonaws.ec2#LaunchTemplateOverrides$AvailabilityZone",
  113    113   
        "com.amazonaws.ec2",
  114    114   
        "LaunchTemplateOverrides",
  115    115   
    ),
  116    116   
    ::aws_smithy_schema::ShapeType::String,
  117         -
    "availability_zone",
         117  +
    "AvailabilityZone",
  118    118   
    3,
  119    119   
)
  120    120   
.with_xml_name("availabilityZone");
  121    121   
static LAUNCHTEMPLATEOVERRIDES_MEMBER_WEIGHTED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static(
  123    123   
        "com.amazonaws.ec2#LaunchTemplateOverrides$WeightedCapacity",
  124    124   
        "com.amazonaws.ec2",
  125    125   
        "LaunchTemplateOverrides",
  126    126   
    ),
  127    127   
    ::aws_smithy_schema::ShapeType::Double,
  128         -
    "weighted_capacity",
         128  +
    "WeightedCapacity",
  129    129   
    4,
  130    130   
)
  131    131   
.with_xml_name("weightedCapacity");
  132    132   
static LAUNCHTEMPLATEOVERRIDES_MEMBER_PRIORITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  133    133   
    ::aws_smithy_schema::ShapeId::from_static(
  134    134   
        "com.amazonaws.ec2#LaunchTemplateOverrides$Priority",
  135    135   
        "com.amazonaws.ec2",
  136    136   
        "LaunchTemplateOverrides",
  137    137   
    ),
  138    138   
    ::aws_smithy_schema::ShapeType::Double,
  139         -
    "priority",
         139  +
    "Priority",
  140    140   
    5,
  141    141   
)
  142    142   
.with_xml_name("priority");
  143    143   
static LAUNCHTEMPLATEOVERRIDES_MEMBER_INSTANCE_REQUIREMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  144    144   
    ::aws_smithy_schema::ShapeId::from_static(
  145    145   
        "com.amazonaws.ec2#LaunchTemplateOverrides$InstanceRequirements",
  146    146   
        "com.amazonaws.ec2",
  147    147   
        "LaunchTemplateOverrides",
  148    148   
    ),
  149    149   
    ::aws_smithy_schema::ShapeType::Structure,
  150         -
    "instance_requirements",
         150  +
    "InstanceRequirements",
  151    151   
    6,
  152    152   
)
  153    153   
.with_xml_name("instanceRequirements");
  154    154   
static LAUNCHTEMPLATEOVERRIDES_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  155    155   
    LAUNCHTEMPLATEOVERRIDES_SCHEMA_ID,
  156    156   
    ::aws_smithy_schema::ShapeType::Structure,
  157    157   
    &[
  158    158   
        &LAUNCHTEMPLATEOVERRIDES_MEMBER_INSTANCE_TYPE,
  159    159   
        &LAUNCHTEMPLATEOVERRIDES_MEMBER_SPOT_PRICE,
  160    160   
        &LAUNCHTEMPLATEOVERRIDES_MEMBER_SUBNET_ID,
  161    161   
        &LAUNCHTEMPLATEOVERRIDES_MEMBER_AVAILABILITY_ZONE,
  162    162   
        &LAUNCHTEMPLATEOVERRIDES_MEMBER_WEIGHTED_CAPACITY,
  163    163   
        &LAUNCHTEMPLATEOVERRIDES_MEMBER_PRIORITY,
  164    164   
        &LAUNCHTEMPLATEOVERRIDES_MEMBER_INSTANCE_REQUIREMENTS,
  165    165   
    ],
  166    166   
);
  167    167   
impl LaunchTemplateOverrides {
  168    168   
    /// The schema for this shape.
  169    169   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATEOVERRIDES_SCHEMA;
  170    170   
}
  171    171   
impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateOverrides {
  172    172   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  173    173   
    fn serialize_members(
  174    174   
        &self,
  175    175   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  176    176   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  177    177   
        if let Some(ref val) = self.instance_type {
  178    178   
            ser.write_string(&LAUNCHTEMPLATEOVERRIDES_MEMBER_INSTANCE_TYPE, val.as_str())?;
  179    179   
        }
  180    180   
        if let Some(ref val) = self.spot_price {
  181    181   
            ser.write_string(&LAUNCHTEMPLATEOVERRIDES_MEMBER_SPOT_PRICE, val)?;
  182    182   
        }
  183    183   
        if let Some(ref val) = self.subnet_id {
  184    184   
            ser.write_string(&LAUNCHTEMPLATEOVERRIDES_MEMBER_SUBNET_ID, val)?;
  185    185   
        }
  186    186   
        if let Some(ref val) = self.availability_zone {
  187    187   
            ser.write_string(&LAUNCHTEMPLATEOVERRIDES_MEMBER_AVAILABILITY_ZONE, val)?;
  188    188   
        }
  189    189   
        if let Some(ref val) = self.weighted_capacity {
  190    190   
            ser.write_double(&LAUNCHTEMPLATEOVERRIDES_MEMBER_WEIGHTED_CAPACITY, *val)?;
  191    191   
        }
  192    192   
        if let Some(ref val) = self.priority {
  193    193   
            ser.write_double(&LAUNCHTEMPLATEOVERRIDES_MEMBER_PRIORITY, *val)?;
  194    194   
        }
  195    195   
        if let Some(ref val) = self.instance_requirements {
  196    196   
            ser.write_struct(&LAUNCHTEMPLATEOVERRIDES_MEMBER_INSTANCE_REQUIREMENTS, val)?;
  197    197   
        }
  198    198   
        Ok(())
  199    199   
    }
  200    200   
}
  201    201   
impl LaunchTemplateOverrides {
  202    202   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  203         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  204         -
        deserializer: &mut D,
         203  +
    pub fn deserialize(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  205    205   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  206    206   
        #[allow(unused_variables, unused_mut)]
  207    207   
        let mut builder = Self::builder();
  208    208   
        #[allow(
  209    209   
            unused_variables,
  210    210   
            unreachable_code,
  211    211   
            clippy::single_match,
  212    212   
            clippy::match_single_binding,
  213    213   
            clippy::diverging_sub_expression
  214    214   
        )]
  215         -
        deserializer.read_struct(&LAUNCHTEMPLATEOVERRIDES_SCHEMA, (), |_, member, deser| {
         215  +
        deserializer.read_struct(&LAUNCHTEMPLATEOVERRIDES_SCHEMA, &mut |member, deser| {
  216    216   
            match member.member_index() {
  217    217   
                Some(0) => {
  218    218   
                    builder.instance_type = Some(crate::types::InstanceType::from(deser.read_string(member)?.as_str()));
  219    219   
                }
  220    220   
                Some(1) => {
  221    221   
                    builder.spot_price = Some(deser.read_string(member)?);
  222    222   
                }
  223    223   
                Some(2) => {
  224    224   
                    builder.subnet_id = Some(deser.read_string(member)?);
  225    225   
                }
  226    226   
                Some(3) => {
  227    227   
                    builder.availability_zone = Some(deser.read_string(member)?);
  228    228   
                }
  229    229   
                Some(4) => {
  230    230   
                    builder.weighted_capacity = Some(deser.read_double(member)?);
  231    231   
                }
  232    232   
                Some(5) => {
  233    233   
                    builder.priority = Some(deser.read_double(member)?);
  234    234   
                }
  235    235   
                Some(6) => {
  236    236   
                    builder.instance_requirements = Some(crate::types::InstanceRequirements::deserialize(deser)?);
  237    237   
                }
  238    238   
                _ => {}
  239    239   
            }
  240    240   
            Ok(())
  241    241   
        })?;
  242    242   
        Ok(builder.build())
  243    243   
    }
  244    244   
}
         245  +
impl LaunchTemplateOverrides {
         246  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         247  +
    pub fn deserialize_with_response(
         248  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         249  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         250  +
        _status: u16,
         251  +
        _body: &[u8],
         252  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         253  +
        Self::deserialize(deserializer)
         254  +
    }
         255  +
}
  245    256   
impl LaunchTemplateOverrides {
  246    257   
    /// Creates a new builder-style object to manufacture [`LaunchTemplateOverrides`](crate::types::LaunchTemplateOverrides).
  247    258   
    pub fn builder() -> crate::types::builders::LaunchTemplateOverridesBuilder {
  248    259   
        crate::types::builders::LaunchTemplateOverridesBuilder::default()
  249    260   
    }
  250    261   
}
  251    262   
  252    263   
/// A builder for [`LaunchTemplateOverrides`](crate::types::LaunchTemplateOverrides).
  253    264   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  254    265   
#[non_exhaustive]

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

@@ -52,52 +211,211 @@
   72     72   
    "com.amazonaws.ec2",
   73     73   
    "LaunchTemplatePlacement",
   74     74   
);
   75     75   
static LAUNCHTEMPLATEPLACEMENT_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static(
   77     77   
        "com.amazonaws.ec2#LaunchTemplatePlacement$AvailabilityZone",
   78     78   
        "com.amazonaws.ec2",
   79     79   
        "LaunchTemplatePlacement",
   80     80   
    ),
   81     81   
    ::aws_smithy_schema::ShapeType::String,
   82         -
    "availability_zone",
          82  +
    "AvailabilityZone",
   83     83   
    0,
   84     84   
)
   85     85   
.with_xml_name("availabilityZone");
   86     86   
static LAUNCHTEMPLATEPLACEMENT_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.ec2#LaunchTemplatePlacement$AvailabilityZoneId",
   89     89   
        "com.amazonaws.ec2",
   90     90   
        "LaunchTemplatePlacement",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::String,
   93         -
    "availability_zone_id",
          93  +
    "AvailabilityZoneId",
   94     94   
    1,
   95     95   
)
   96     96   
.with_xml_name("availabilityZoneId");
   97     97   
static LAUNCHTEMPLATEPLACEMENT_MEMBER_AFFINITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.ec2#LaunchTemplatePlacement$Affinity",
  100    100   
        "com.amazonaws.ec2",
  101    101   
        "LaunchTemplatePlacement",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::String,
  104         -
    "affinity",
         104  +
    "Affinity",
  105    105   
    2,
  106    106   
)
  107    107   
.with_xml_name("affinity");
  108    108   
static LAUNCHTEMPLATEPLACEMENT_MEMBER_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static(
  110    110   
        "com.amazonaws.ec2#LaunchTemplatePlacement$GroupName",
  111    111   
        "com.amazonaws.ec2",
  112    112   
        "LaunchTemplatePlacement",
  113    113   
    ),
  114    114   
    ::aws_smithy_schema::ShapeType::String,
  115         -
    "group_name",
         115  +
    "GroupName",
  116    116   
    3,
  117    117   
)
  118    118   
.with_xml_name("groupName");
  119    119   
static LAUNCHTEMPLATEPLACEMENT_MEMBER_HOST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.ec2#LaunchTemplatePlacement$HostId",
  122    122   
        "com.amazonaws.ec2",
  123    123   
        "LaunchTemplatePlacement",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::String,
  126         -
    "host_id",
         126  +
    "HostId",
  127    127   
    4,
  128    128   
)
  129    129   
.with_xml_name("hostId");
  130    130   
static LAUNCHTEMPLATEPLACEMENT_MEMBER_TENANCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static(
  132    132   
        "com.amazonaws.ec2#LaunchTemplatePlacement$Tenancy",
  133    133   
        "com.amazonaws.ec2",
  134    134   
        "LaunchTemplatePlacement",
  135    135   
    ),
  136    136   
    ::aws_smithy_schema::ShapeType::String,
  137         -
    "tenancy",
         137  +
    "Tenancy",
  138    138   
    5,
  139    139   
)
  140    140   
.with_xml_name("tenancy");
  141    141   
static LAUNCHTEMPLATEPLACEMENT_MEMBER_SPREAD_DOMAIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  142    142   
    ::aws_smithy_schema::ShapeId::from_static(
  143    143   
        "com.amazonaws.ec2#LaunchTemplatePlacement$SpreadDomain",
  144    144   
        "com.amazonaws.ec2",
  145    145   
        "LaunchTemplatePlacement",
  146    146   
    ),
  147    147   
    ::aws_smithy_schema::ShapeType::String,
  148         -
    "spread_domain",
         148  +
    "SpreadDomain",
  149    149   
    6,
  150    150   
)
  151    151   
.with_xml_name("spreadDomain");
  152    152   
static LAUNCHTEMPLATEPLACEMENT_MEMBER_HOST_RESOURCE_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  153    153   
    ::aws_smithy_schema::ShapeId::from_static(
  154    154   
        "com.amazonaws.ec2#LaunchTemplatePlacement$HostResourceGroupArn",
  155    155   
        "com.amazonaws.ec2",
  156    156   
        "LaunchTemplatePlacement",
  157    157   
    ),
  158    158   
    ::aws_smithy_schema::ShapeType::String,
  159         -
    "host_resource_group_arn",
         159  +
    "HostResourceGroupArn",
  160    160   
    7,
  161    161   
)
  162    162   
.with_xml_name("hostResourceGroupArn");
  163    163   
static LAUNCHTEMPLATEPLACEMENT_MEMBER_PARTITION_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  164    164   
    ::aws_smithy_schema::ShapeId::from_static(
  165    165   
        "com.amazonaws.ec2#LaunchTemplatePlacement$PartitionNumber",
  166    166   
        "com.amazonaws.ec2",
  167    167   
        "LaunchTemplatePlacement",
  168    168   
    ),
  169    169   
    ::aws_smithy_schema::ShapeType::Integer,
  170         -
    "partition_number",
         170  +
    "PartitionNumber",
  171    171   
    8,
  172    172   
)
  173    173   
.with_xml_name("partitionNumber");
  174    174   
static LAUNCHTEMPLATEPLACEMENT_MEMBER_GROUP_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  175    175   
    ::aws_smithy_schema::ShapeId::from_static(
  176    176   
        "com.amazonaws.ec2#LaunchTemplatePlacement$GroupId",
  177    177   
        "com.amazonaws.ec2",
  178    178   
        "LaunchTemplatePlacement",
  179    179   
    ),
  180    180   
    ::aws_smithy_schema::ShapeType::String,
  181         -
    "group_id",
         181  +
    "GroupId",
  182    182   
    9,
  183    183   
)
  184    184   
.with_xml_name("groupId");
  185    185   
static LAUNCHTEMPLATEPLACEMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  186    186   
    LAUNCHTEMPLATEPLACEMENT_SCHEMA_ID,
  187    187   
    ::aws_smithy_schema::ShapeType::Structure,
  188    188   
    &[
  189    189   
        &LAUNCHTEMPLATEPLACEMENT_MEMBER_AVAILABILITY_ZONE,
  190    190   
        &LAUNCHTEMPLATEPLACEMENT_MEMBER_AVAILABILITY_ZONE_ID,
  191    191   
        &LAUNCHTEMPLATEPLACEMENT_MEMBER_AFFINITY,
@@ -216,216 +326,337 @@
  236    236   
            ser.write_integer(&LAUNCHTEMPLATEPLACEMENT_MEMBER_PARTITION_NUMBER, *val)?;
  237    237   
        }
  238    238   
        if let Some(ref val) = self.group_id {
  239    239   
            ser.write_string(&LAUNCHTEMPLATEPLACEMENT_MEMBER_GROUP_ID, val)?;
  240    240   
        }
  241    241   
        Ok(())
  242    242   
    }
  243    243   
}
  244    244   
impl LaunchTemplatePlacement {
  245    245   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  246         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  247         -
        deserializer: &mut D,
         246  +
    pub fn deserialize(
         247  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  248    248   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  249    249   
        #[allow(unused_variables, unused_mut)]
  250    250   
        let mut builder = Self::builder();
  251    251   
        #[allow(
  252    252   
            unused_variables,
  253    253   
            unreachable_code,
  254    254   
            clippy::single_match,
  255    255   
            clippy::match_single_binding,
  256    256   
            clippy::diverging_sub_expression
  257    257   
        )]
  258         -
        deserializer.read_struct(&LAUNCHTEMPLATEPLACEMENT_SCHEMA, (), |_, member, deser| {
         258  +
        deserializer.read_struct(&LAUNCHTEMPLATEPLACEMENT_SCHEMA, &mut |member, deser| {
  259    259   
            match member.member_index() {
  260    260   
                Some(0) => {
  261    261   
                    builder.availability_zone = Some(deser.read_string(member)?);
  262    262   
                }
  263    263   
                Some(1) => {
  264    264   
                    builder.availability_zone_id = Some(deser.read_string(member)?);
  265    265   
                }
  266    266   
                Some(2) => {
  267    267   
                    builder.affinity = Some(deser.read_string(member)?);
  268    268   
                }
  269    269   
                Some(3) => {
  270    270   
                    builder.group_name = Some(deser.read_string(member)?);
  271    271   
                }
  272    272   
                Some(4) => {
  273    273   
                    builder.host_id = Some(deser.read_string(member)?);
  274    274   
                }
  275    275   
                Some(5) => {
  276    276   
                    builder.tenancy = Some(crate::types::Tenancy::from(deser.read_string(member)?.as_str()));
  277    277   
                }
  278    278   
                Some(6) => {
  279    279   
                    builder.spread_domain = Some(deser.read_string(member)?);
  280    280   
                }
  281    281   
                Some(7) => {
  282    282   
                    builder.host_resource_group_arn = Some(deser.read_string(member)?);
  283    283   
                }
  284    284   
                Some(8) => {
  285    285   
                    builder.partition_number = Some(deser.read_integer(member)?);
  286    286   
                }
  287    287   
                Some(9) => {
  288    288   
                    builder.group_id = Some(deser.read_string(member)?);
  289    289   
                }
  290    290   
                _ => {}
  291    291   
            }
  292    292   
            Ok(())
  293    293   
        })?;
  294    294   
        Ok(builder.build())
  295    295   
    }
  296    296   
}
         297  +
impl LaunchTemplatePlacement {
         298  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         299  +
    pub fn deserialize_with_response(
         300  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         301  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         302  +
        _status: u16,
         303  +
        _body: &[u8],
         304  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         305  +
        Self::deserialize(deserializer)
         306  +
    }
         307  +
}
  297    308   
impl LaunchTemplatePlacement {
  298    309   
    /// Creates a new builder-style object to manufacture [`LaunchTemplatePlacement`](crate::types::LaunchTemplatePlacement).
  299    310   
    pub fn builder() -> crate::types::builders::LaunchTemplatePlacementBuilder {
  300    311   
        crate::types::builders::LaunchTemplatePlacementBuilder::default()
  301    312   
    }
  302    313   
}
  303    314   
  304    315   
/// A builder for [`LaunchTemplatePlacement`](crate::types::LaunchTemplatePlacement).
  305    316   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  306    317   
#[non_exhaustive]

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

@@ -56,56 +206,206 @@
   76     76   
    "com.amazonaws.ec2",
   77     77   
    "LaunchTemplatePlacementRequest",
   78     78   
);
   79     79   
static LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.ec2#LaunchTemplatePlacementRequest$AvailabilityZone",
   82     82   
        "com.amazonaws.ec2",
   83     83   
        "LaunchTemplatePlacementRequest",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86         -
    "availability_zone",
          86  +
    "AvailabilityZone",
   87     87   
    0,
   88     88   
);
   89     89   
static LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.ec2#LaunchTemplatePlacementRequest$AvailabilityZoneId",
   92     92   
        "com.amazonaws.ec2",
   93     93   
        "LaunchTemplatePlacementRequest",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::String,
   96         -
    "availability_zone_id",
          96  +
    "AvailabilityZoneId",
   97     97   
    1,
   98     98   
);
   99     99   
static LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_AFFINITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.ec2#LaunchTemplatePlacementRequest$Affinity",
  102    102   
        "com.amazonaws.ec2",
  103    103   
        "LaunchTemplatePlacementRequest",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::String,
  106         -
    "affinity",
         106  +
    "Affinity",
  107    107   
    2,
  108    108   
);
  109    109   
static LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.ec2#LaunchTemplatePlacementRequest$GroupName",
  112    112   
        "com.amazonaws.ec2",
  113    113   
        "LaunchTemplatePlacementRequest",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "group_name",
         116  +
    "GroupName",
  117    117   
    3,
  118    118   
);
  119    119   
static LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_HOST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.ec2#LaunchTemplatePlacementRequest$HostId",
  122    122   
        "com.amazonaws.ec2",
  123    123   
        "LaunchTemplatePlacementRequest",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::String,
  126         -
    "host_id",
         126  +
    "HostId",
  127    127   
    4,
  128    128   
);
  129    129   
static LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_TENANCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static(
  131    131   
        "com.amazonaws.ec2#LaunchTemplatePlacementRequest$Tenancy",
  132    132   
        "com.amazonaws.ec2",
  133    133   
        "LaunchTemplatePlacementRequest",
  134    134   
    ),
  135    135   
    ::aws_smithy_schema::ShapeType::String,
  136         -
    "tenancy",
         136  +
    "Tenancy",
  137    137   
    5,
  138    138   
);
  139    139   
static LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_SPREAD_DOMAIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static(
  141    141   
        "com.amazonaws.ec2#LaunchTemplatePlacementRequest$SpreadDomain",
  142    142   
        "com.amazonaws.ec2",
  143    143   
        "LaunchTemplatePlacementRequest",
  144    144   
    ),
  145    145   
    ::aws_smithy_schema::ShapeType::String,
  146         -
    "spread_domain",
         146  +
    "SpreadDomain",
  147    147   
    6,
  148    148   
);
  149    149   
static LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_HOST_RESOURCE_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static(
  151    151   
        "com.amazonaws.ec2#LaunchTemplatePlacementRequest$HostResourceGroupArn",
  152    152   
        "com.amazonaws.ec2",
  153    153   
        "LaunchTemplatePlacementRequest",
  154    154   
    ),
  155    155   
    ::aws_smithy_schema::ShapeType::String,
  156         -
    "host_resource_group_arn",
         156  +
    "HostResourceGroupArn",
  157    157   
    7,
  158    158   
);
  159    159   
static LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_PARTITION_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  160    160   
    ::aws_smithy_schema::ShapeId::from_static(
  161    161   
        "com.amazonaws.ec2#LaunchTemplatePlacementRequest$PartitionNumber",
  162    162   
        "com.amazonaws.ec2",
  163    163   
        "LaunchTemplatePlacementRequest",
  164    164   
    ),
  165    165   
    ::aws_smithy_schema::ShapeType::Integer,
  166         -
    "partition_number",
         166  +
    "PartitionNumber",
  167    167   
    8,
  168    168   
);
  169    169   
static LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_GROUP_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  170    170   
    ::aws_smithy_schema::ShapeId::from_static(
  171    171   
        "com.amazonaws.ec2#LaunchTemplatePlacementRequest$GroupId",
  172    172   
        "com.amazonaws.ec2",
  173    173   
        "LaunchTemplatePlacementRequest",
  174    174   
    ),
  175    175   
    ::aws_smithy_schema::ShapeType::String,
  176         -
    "group_id",
         176  +
    "GroupId",
  177    177   
    9,
  178    178   
);
  179    179   
static LAUNCHTEMPLATEPLACEMENTREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  180    180   
    LAUNCHTEMPLATEPLACEMENTREQUEST_SCHEMA_ID,
  181    181   
    ::aws_smithy_schema::ShapeType::Structure,
  182    182   
    &[
  183    183   
        &LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_AVAILABILITY_ZONE,
  184    184   
        &LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_AVAILABILITY_ZONE_ID,
  185    185   
        &LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_AFFINITY,
  186    186   
        &LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_GROUP_NAME,
@@ -210,210 +320,331 @@
  230    230   
            ser.write_integer(&LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_PARTITION_NUMBER, *val)?;
  231    231   
        }
  232    232   
        if let Some(ref val) = self.group_id {
  233    233   
            ser.write_string(&LAUNCHTEMPLATEPLACEMENTREQUEST_MEMBER_GROUP_ID, val)?;
  234    234   
        }
  235    235   
        Ok(())
  236    236   
    }
  237    237   
}
  238    238   
impl LaunchTemplatePlacementRequest {
  239    239   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  240         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  241         -
        deserializer: &mut D,
         240  +
    pub fn deserialize(
         241  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  242    242   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  243    243   
        #[allow(unused_variables, unused_mut)]
  244    244   
        let mut builder = Self::builder();
  245    245   
        #[allow(
  246    246   
            unused_variables,
  247    247   
            unreachable_code,
  248    248   
            clippy::single_match,
  249    249   
            clippy::match_single_binding,
  250    250   
            clippy::diverging_sub_expression
  251    251   
        )]
  252         -
        deserializer.read_struct(&LAUNCHTEMPLATEPLACEMENTREQUEST_SCHEMA, (), |_, member, deser| {
         252  +
        deserializer.read_struct(&LAUNCHTEMPLATEPLACEMENTREQUEST_SCHEMA, &mut |member, deser| {
  253    253   
            match member.member_index() {
  254    254   
                Some(0) => {
  255    255   
                    builder.availability_zone = Some(deser.read_string(member)?);
  256    256   
                }
  257    257   
                Some(1) => {
  258    258   
                    builder.availability_zone_id = Some(deser.read_string(member)?);
  259    259   
                }
  260    260   
                Some(2) => {
  261    261   
                    builder.affinity = Some(deser.read_string(member)?);
  262    262   
                }
  263    263   
                Some(3) => {
  264    264   
                    builder.group_name = Some(deser.read_string(member)?);
  265    265   
                }
  266    266   
                Some(4) => {
  267    267   
                    builder.host_id = Some(deser.read_string(member)?);
  268    268   
                }
  269    269   
                Some(5) => {
  270    270   
                    builder.tenancy = Some(crate::types::Tenancy::from(deser.read_string(member)?.as_str()));
  271    271   
                }
  272    272   
                Some(6) => {
  273    273   
                    builder.spread_domain = Some(deser.read_string(member)?);
  274    274   
                }
  275    275   
                Some(7) => {
  276    276   
                    builder.host_resource_group_arn = Some(deser.read_string(member)?);
  277    277   
                }
  278    278   
                Some(8) => {
  279    279   
                    builder.partition_number = Some(deser.read_integer(member)?);
  280    280   
                }
  281    281   
                Some(9) => {
  282    282   
                    builder.group_id = Some(deser.read_string(member)?);
  283    283   
                }
  284    284   
                _ => {}
  285    285   
            }
  286    286   
            Ok(())
  287    287   
        })?;
  288    288   
        Ok(builder.build())
  289    289   
    }
  290    290   
}
         291  +
impl LaunchTemplatePlacementRequest {
         292  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         293  +
    pub fn deserialize_with_response(
         294  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         295  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         296  +
        _status: u16,
         297  +
        _body: &[u8],
         298  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         299  +
        Self::deserialize(deserializer)
         300  +
    }
         301  +
}
  291    302   
impl LaunchTemplatePlacementRequest {
  292    303   
    /// Creates a new builder-style object to manufacture [`LaunchTemplatePlacementRequest`](crate::types::LaunchTemplatePlacementRequest).
  293    304   
    pub fn builder() -> crate::types::builders::LaunchTemplatePlacementRequestBuilder {
  294    305   
        crate::types::builders::LaunchTemplatePlacementRequestBuilder::default()
  295    306   
    }
  296    307   
}
  297    308   
  298    309   
/// A builder for [`LaunchTemplatePlacementRequest`](crate::types::LaunchTemplatePlacementRequest).
  299    310   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  300    311   
#[non_exhaustive]

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

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

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

@@ -10,10 +160,171 @@
   30     30   
    "com.amazonaws.ec2",
   31     31   
    "LaunchTemplatePrivateDnsNameOptionsRequest",
   32     32   
);
   33     33   
static LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_MEMBER_HOSTNAME_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.ec2#LaunchTemplatePrivateDnsNameOptionsRequest$HostnameType",
   36     36   
        "com.amazonaws.ec2",
   37     37   
        "LaunchTemplatePrivateDnsNameOptionsRequest",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::String,
   40         -
    "hostname_type",
          40  +
    "HostnameType",
   41     41   
    0,
   42     42   
);
   43     43   
static LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_MEMBER_ENABLE_RESOURCE_NAME_DNS_A_RECORD: ::aws_smithy_schema::Schema =
   44     44   
    ::aws_smithy_schema::Schema::new_member(
   45     45   
        ::aws_smithy_schema::ShapeId::from_static(
   46     46   
            "com.amazonaws.ec2#LaunchTemplatePrivateDnsNameOptionsRequest$EnableResourceNameDnsARecord",
   47     47   
            "com.amazonaws.ec2",
   48     48   
            "LaunchTemplatePrivateDnsNameOptionsRequest",
   49     49   
        ),
   50     50   
        ::aws_smithy_schema::ShapeType::Boolean,
   51         -
        "enable_resource_name_dns_a_record",
          51  +
        "EnableResourceNameDnsARecord",
   52     52   
        1,
   53     53   
    );
   54     54   
static LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_MEMBER_ENABLE_RESOURCE_NAME_DNS_AAAA_RECORD: ::aws_smithy_schema::Schema =
   55     55   
    ::aws_smithy_schema::Schema::new_member(
   56     56   
        ::aws_smithy_schema::ShapeId::from_static(
   57     57   
            "com.amazonaws.ec2#LaunchTemplatePrivateDnsNameOptionsRequest$EnableResourceNameDnsAAAARecord",
   58     58   
            "com.amazonaws.ec2",
   59     59   
            "LaunchTemplatePrivateDnsNameOptionsRequest",
   60     60   
        ),
   61     61   
        ::aws_smithy_schema::ShapeType::Boolean,
   62         -
        "enable_resource_name_dns_aaaa_record",
          62  +
        "EnableResourceNameDnsAAAARecord",
   63     63   
        2,
   64     64   
    );
   65     65   
static LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   66     66   
    LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_SCHEMA_ID,
   67     67   
    ::aws_smithy_schema::ShapeType::Structure,
   68     68   
    &[
   69     69   
        &LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_MEMBER_HOSTNAME_TYPE,
   70     70   
        &LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_MEMBER_ENABLE_RESOURCE_NAME_DNS_A_RECORD,
   71     71   
        &LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_MEMBER_ENABLE_RESOURCE_NAME_DNS_AAAA_RECORD,
   72     72   
    ],
   73     73   
);
   74     74   
impl LaunchTemplatePrivateDnsNameOptionsRequest {
   75     75   
    /// The schema for this shape.
   76     76   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_SCHEMA;
   77     77   
}
   78     78   
impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplatePrivateDnsNameOptionsRequest {
   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.hostname_type {
   85     85   
            ser.write_string(&LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_MEMBER_HOSTNAME_TYPE, val.as_str())?;
   86     86   
        }
   87     87   
        if let Some(ref val) = self.enable_resource_name_dns_a_record {
   88     88   
            ser.write_boolean(&LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_MEMBER_ENABLE_RESOURCE_NAME_DNS_A_RECORD, *val)?;
   89     89   
        }
   90     90   
        if let Some(ref val) = self.enable_resource_name_dns_aaaa_record {
   91     91   
            ser.write_boolean(
   92     92   
                &LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_MEMBER_ENABLE_RESOURCE_NAME_DNS_AAAA_RECORD,
   93     93   
                *val,
   94     94   
            )?;
   95     95   
        }
   96     96   
        Ok(())
   97     97   
    }
   98     98   
}
   99     99   
impl LaunchTemplatePrivateDnsNameOptionsRequest {
  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(&LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_SCHEMA, (), |_, member, deser| {
         113  +
        deserializer.read_struct(&LAUNCHTEMPLATEPRIVATEDNSNAMEOPTIONSREQUEST_SCHEMA, &mut |member, deser| {
  114    114   
            match member.member_index() {
  115    115   
                Some(0) => {
  116    116   
                    builder.hostname_type = Some(crate::types::HostnameType::from(deser.read_string(member)?.as_str()));
  117    117   
                }
  118    118   
                Some(1) => {
  119    119   
                    builder.enable_resource_name_dns_a_record = Some(deser.read_boolean(member)?);
  120    120   
                }
  121    121   
                Some(2) => {
  122    122   
                    builder.enable_resource_name_dns_aaaa_record = Some(deser.read_boolean(member)?);
  123    123   
                }
  124    124   
                _ => {}
  125    125   
            }
  126    126   
            Ok(())
  127    127   
        })?;
  128    128   
        Ok(builder.build())
  129    129   
    }
  130    130   
}
         131  +
impl LaunchTemplatePrivateDnsNameOptionsRequest {
         132  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         133  +
    pub fn deserialize_with_response(
         134  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         135  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         136  +
        _status: u16,
         137  +
        _body: &[u8],
         138  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         139  +
        Self::deserialize(deserializer)
         140  +
    }
         141  +
}
  131    142   
impl LaunchTemplatePrivateDnsNameOptionsRequest {
  132    143   
    /// Creates a new builder-style object to manufacture [`LaunchTemplatePrivateDnsNameOptionsRequest`](crate::types::LaunchTemplatePrivateDnsNameOptionsRequest).
  133    144   
    pub fn builder() -> crate::types::builders::LaunchTemplatePrivateDnsNameOptionsRequestBuilder {
  134    145   
        crate::types::builders::LaunchTemplatePrivateDnsNameOptionsRequestBuilder::default()
  135    146   
    }
  136    147   
}
  137    148   
  138    149   
/// A builder for [`LaunchTemplatePrivateDnsNameOptionsRequest`](crate::types::LaunchTemplatePrivateDnsNameOptionsRequest).
  139    150   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  140    151   
#[non_exhaustive]

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

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

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

@@ -22,22 +207,218 @@
   42     42   
    "com.amazonaws.ec2",
   43     43   
    "LaunchTemplateSpotMarketOptions",
   44     44   
);
   45     45   
static LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_MAX_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static(
   47     47   
        "com.amazonaws.ec2#LaunchTemplateSpotMarketOptions$MaxPrice",
   48     48   
        "com.amazonaws.ec2",
   49     49   
        "LaunchTemplateSpotMarketOptions",
   50     50   
    ),
   51     51   
    ::aws_smithy_schema::ShapeType::String,
   52         -
    "max_price",
          52  +
    "MaxPrice",
   53     53   
    0,
   54     54   
)
   55     55   
.with_xml_name("maxPrice");
   56     56   
static LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_SPOT_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "com.amazonaws.ec2#LaunchTemplateSpotMarketOptions$SpotInstanceType",
   59     59   
        "com.amazonaws.ec2",
   60     60   
        "LaunchTemplateSpotMarketOptions",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "spot_instance_type",
          63  +
    "SpotInstanceType",
   64     64   
    1,
   65     65   
)
   66     66   
.with_xml_name("spotInstanceType");
   67     67   
static LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_BLOCK_DURATION_MINUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.ec2#LaunchTemplateSpotMarketOptions$BlockDurationMinutes",
   70     70   
        "com.amazonaws.ec2",
   71     71   
        "LaunchTemplateSpotMarketOptions",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::Integer,
   74         -
    "block_duration_minutes",
          74  +
    "BlockDurationMinutes",
   75     75   
    2,
   76     76   
)
   77     77   
.with_xml_name("blockDurationMinutes");
   78     78   
static LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_VALID_UNTIL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.ec2#LaunchTemplateSpotMarketOptions$ValidUntil",
   81     81   
        "com.amazonaws.ec2",
   82     82   
        "LaunchTemplateSpotMarketOptions",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::Timestamp,
   85         -
    "valid_until",
          85  +
    "ValidUntil",
   86     86   
    3,
   87     87   
)
   88     88   
.with_xml_name("validUntil");
   89     89   
static LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.ec2#LaunchTemplateSpotMarketOptions$InstanceInterruptionBehavior",
   92     92   
        "com.amazonaws.ec2",
   93     93   
        "LaunchTemplateSpotMarketOptions",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::String,
   96         -
    "instance_interruption_behavior",
          96  +
    "InstanceInterruptionBehavior",
   97     97   
    4,
   98     98   
)
   99     99   
.with_xml_name("instanceInterruptionBehavior");
  100    100   
static LAUNCHTEMPLATESPOTMARKETOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  101    101   
    LAUNCHTEMPLATESPOTMARKETOPTIONS_SCHEMA_ID,
  102    102   
    ::aws_smithy_schema::ShapeType::Structure,
  103    103   
    &[
  104    104   
        &LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_MAX_PRICE,
  105    105   
        &LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_SPOT_INSTANCE_TYPE,
  106    106   
        &LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_BLOCK_DURATION_MINUTES,
  107    107   
        &LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_VALID_UNTIL,
  108    108   
        &LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR,
  109    109   
    ],
  110    110   
);
  111    111   
impl LaunchTemplateSpotMarketOptions {
  112    112   
    /// The schema for this shape.
  113    113   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATESPOTMARKETOPTIONS_SCHEMA;
  114    114   
}
  115    115   
impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateSpotMarketOptions {
  116    116   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  117    117   
    fn serialize_members(
  118    118   
        &self,
  119    119   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  120    120   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  121    121   
        if let Some(ref val) = self.max_price {
  122    122   
            ser.write_string(&LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_MAX_PRICE, val)?;
  123    123   
        }
  124    124   
        if let Some(ref val) = self.spot_instance_type {
  125    125   
            ser.write_string(&LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_SPOT_INSTANCE_TYPE, val.as_str())?;
  126    126   
        }
  127    127   
        if let Some(ref val) = self.block_duration_minutes {
  128    128   
            ser.write_integer(&LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_BLOCK_DURATION_MINUTES, *val)?;
  129    129   
        }
  130    130   
        if let Some(ref val) = self.valid_until {
  131    131   
            ser.write_timestamp(&LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_VALID_UNTIL, val)?;
  132    132   
        }
  133    133   
        if let Some(ref val) = self.instance_interruption_behavior {
  134    134   
            ser.write_string(&LAUNCHTEMPLATESPOTMARKETOPTIONS_MEMBER_INSTANCE_INTERRUPTION_BEHAVIOR, val.as_str())?;
  135    135   
        }
  136    136   
        Ok(())
  137    137   
    }
  138    138   
}
  139    139   
impl LaunchTemplateSpotMarketOptions {
  140    140   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  141         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  142         -
        deserializer: &mut D,
         141  +
    pub fn deserialize(
         142  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  143    143   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  144    144   
        #[allow(unused_variables, unused_mut)]
  145    145   
        let mut builder = Self::builder();
  146    146   
        #[allow(
  147    147   
            unused_variables,
  148    148   
            unreachable_code,
  149    149   
            clippy::single_match,
  150    150   
            clippy::match_single_binding,
  151    151   
            clippy::diverging_sub_expression
  152    152   
        )]
  153         -
        deserializer.read_struct(&LAUNCHTEMPLATESPOTMARKETOPTIONS_SCHEMA, (), |_, member, deser| {
         153  +
        deserializer.read_struct(&LAUNCHTEMPLATESPOTMARKETOPTIONS_SCHEMA, &mut |member, deser| {
  154    154   
            match member.member_index() {
  155    155   
                Some(0) => {
  156    156   
                    builder.max_price = Some(deser.read_string(member)?);
  157    157   
                }
  158    158   
                Some(1) => {
  159    159   
                    builder.spot_instance_type = Some(crate::types::SpotInstanceType::from(deser.read_string(member)?.as_str()));
  160    160   
                }
  161    161   
                Some(2) => {
  162    162   
                    builder.block_duration_minutes = Some(deser.read_integer(member)?);
  163    163   
                }
  164    164   
                Some(3) => {
  165    165   
                    builder.valid_until = Some(deser.read_timestamp(member)?);
  166    166   
                }
  167    167   
                Some(4) => {
  168    168   
                    builder.instance_interruption_behavior =
  169    169   
                        Some(crate::types::InstanceInterruptionBehavior::from(deser.read_string(member)?.as_str()));
  170    170   
                }
  171    171   
                _ => {}
  172    172   
            }
  173    173   
            Ok(())
  174    174   
        })?;
  175    175   
        Ok(builder.build())
  176    176   
    }
  177    177   
}
         178  +
impl LaunchTemplateSpotMarketOptions {
         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  +
}
  178    189   
impl LaunchTemplateSpotMarketOptions {
  179    190   
    /// Creates a new builder-style object to manufacture [`LaunchTemplateSpotMarketOptions`](crate::types::LaunchTemplateSpotMarketOptions).
  180    191   
    pub fn builder() -> crate::types::builders::LaunchTemplateSpotMarketOptionsBuilder {
  181    192   
        crate::types::builders::LaunchTemplateSpotMarketOptionsBuilder::default()
  182    193   
    }
  183    194   
}
  184    195   
  185    196   
/// A builder for [`LaunchTemplateSpotMarketOptions`](crate::types::LaunchTemplateSpotMarketOptions).
  186    197   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  187    198   
#[non_exhaustive]

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

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

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

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

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

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

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

@@ -43,43 +299,310 @@
   63     63   
}
   64     64   
static LAUNCHTEMPLATEVERSION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   65     65   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#LaunchTemplateVersion", "com.amazonaws.ec2", "LaunchTemplateVersion");
   66     66   
static LAUNCHTEMPLATEVERSION_MEMBER_LAUNCH_TEMPLATE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "com.amazonaws.ec2#LaunchTemplateVersion$LaunchTemplateId",
   69     69   
        "com.amazonaws.ec2",
   70     70   
        "LaunchTemplateVersion",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::String,
   73         -
    "launch_template_id",
          73  +
    "LaunchTemplateId",
   74     74   
    0,
   75     75   
)
   76     76   
.with_xml_name("launchTemplateId");
   77     77   
static LAUNCHTEMPLATEVERSION_MEMBER_LAUNCH_TEMPLATE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.ec2#LaunchTemplateVersion$LaunchTemplateName",
   80     80   
        "com.amazonaws.ec2",
   81     81   
        "LaunchTemplateVersion",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "launch_template_name",
          84  +
    "LaunchTemplateName",
   85     85   
    1,
   86     86   
)
   87     87   
.with_xml_name("launchTemplateName");
   88     88   
static LAUNCHTEMPLATEVERSION_MEMBER_VERSION_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.ec2#LaunchTemplateVersion$VersionNumber",
   91     91   
        "com.amazonaws.ec2",
   92     92   
        "LaunchTemplateVersion",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::Long,
   95         -
    "version_number",
          95  +
    "VersionNumber",
   96     96   
    2,
   97     97   
)
   98     98   
.with_xml_name("versionNumber");
   99     99   
static LAUNCHTEMPLATEVERSION_MEMBER_VERSION_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.ec2#LaunchTemplateVersion$VersionDescription",
  102    102   
        "com.amazonaws.ec2",
  103    103   
        "LaunchTemplateVersion",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::String,
  106         -
    "version_description",
         106  +
    "VersionDescription",
  107    107   
    3,
  108    108   
)
  109    109   
.with_xml_name("versionDescription");
  110    110   
static LAUNCHTEMPLATEVERSION_MEMBER_CREATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static(
  112    112   
        "com.amazonaws.ec2#LaunchTemplateVersion$CreateTime",
  113    113   
        "com.amazonaws.ec2",
  114    114   
        "LaunchTemplateVersion",
  115    115   
    ),
  116    116   
    ::aws_smithy_schema::ShapeType::Timestamp,
  117         -
    "create_time",
         117  +
    "CreateTime",
  118    118   
    4,
  119    119   
)
  120    120   
.with_xml_name("createTime");
  121    121   
static LAUNCHTEMPLATEVERSION_MEMBER_CREATED_BY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static(
  123    123   
        "com.amazonaws.ec2#LaunchTemplateVersion$CreatedBy",
  124    124   
        "com.amazonaws.ec2",
  125    125   
        "LaunchTemplateVersion",
  126    126   
    ),
  127    127   
    ::aws_smithy_schema::ShapeType::String,
  128         -
    "created_by",
         128  +
    "CreatedBy",
  129    129   
    5,
  130    130   
)
  131    131   
.with_xml_name("createdBy");
  132    132   
static LAUNCHTEMPLATEVERSION_MEMBER_DEFAULT_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  133    133   
    ::aws_smithy_schema::ShapeId::from_static(
  134    134   
        "com.amazonaws.ec2#LaunchTemplateVersion$DefaultVersion",
  135    135   
        "com.amazonaws.ec2",
  136    136   
        "LaunchTemplateVersion",
  137    137   
    ),
  138    138   
    ::aws_smithy_schema::ShapeType::Boolean,
  139         -
    "default_version",
         139  +
    "DefaultVersion",
  140    140   
    6,
  141    141   
)
  142    142   
.with_xml_name("defaultVersion");
  143    143   
static LAUNCHTEMPLATEVERSION_MEMBER_LAUNCH_TEMPLATE_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  144    144   
    ::aws_smithy_schema::ShapeId::from_static(
  145    145   
        "com.amazonaws.ec2#LaunchTemplateVersion$LaunchTemplateData",
  146    146   
        "com.amazonaws.ec2",
  147    147   
        "LaunchTemplateVersion",
  148    148   
    ),
  149    149   
    ::aws_smithy_schema::ShapeType::Structure,
  150         -
    "launch_template_data",
         150  +
    "LaunchTemplateData",
  151    151   
    7,
  152    152   
)
  153    153   
.with_xml_name("launchTemplateData");
  154    154   
static LAUNCHTEMPLATEVERSION_MEMBER_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  155    155   
    ::aws_smithy_schema::ShapeId::from_static(
  156    156   
        "com.amazonaws.ec2#LaunchTemplateVersion$Operator",
  157    157   
        "com.amazonaws.ec2",
  158    158   
        "LaunchTemplateVersion",
  159    159   
    ),
  160    160   
    ::aws_smithy_schema::ShapeType::Structure,
  161         -
    "operator",
         161  +
    "Operator",
  162    162   
    8,
  163    163   
)
  164    164   
.with_xml_name("operator");
  165    165   
static LAUNCHTEMPLATEVERSION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  166    166   
    LAUNCHTEMPLATEVERSION_SCHEMA_ID,
  167    167   
    ::aws_smithy_schema::ShapeType::Structure,
  168    168   
    &[
  169    169   
        &LAUNCHTEMPLATEVERSION_MEMBER_LAUNCH_TEMPLATE_ID,
  170    170   
        &LAUNCHTEMPLATEVERSION_MEMBER_LAUNCH_TEMPLATE_NAME,
  171    171   
        &LAUNCHTEMPLATEVERSION_MEMBER_VERSION_NUMBER,
  172    172   
        &LAUNCHTEMPLATEVERSION_MEMBER_VERSION_DESCRIPTION,
  173    173   
        &LAUNCHTEMPLATEVERSION_MEMBER_CREATE_TIME,
  174    174   
        &LAUNCHTEMPLATEVERSION_MEMBER_CREATED_BY,
  175    175   
        &LAUNCHTEMPLATEVERSION_MEMBER_DEFAULT_VERSION,
  176    176   
        &LAUNCHTEMPLATEVERSION_MEMBER_LAUNCH_TEMPLATE_DATA,
  177    177   
        &LAUNCHTEMPLATEVERSION_MEMBER_OPERATOR,
  178    178   
    ],
  179    179   
);
  180    180   
impl LaunchTemplateVersion {
  181    181   
    /// The schema for this shape.
  182    182   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAUNCHTEMPLATEVERSION_SCHEMA;
  183    183   
}
  184    184   
impl ::aws_smithy_schema::serde::SerializableStruct for LaunchTemplateVersion {
  185    185   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  186    186   
    fn serialize_members(
  187    187   
        &self,
  188    188   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  189    189   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  190    190   
        if let Some(ref val) = self.launch_template_id {
  191    191   
            ser.write_string(&LAUNCHTEMPLATEVERSION_MEMBER_LAUNCH_TEMPLATE_ID, val)?;
  192    192   
        }
  193    193   
        if let Some(ref val) = self.launch_template_name {
  194    194   
            ser.write_string(&LAUNCHTEMPLATEVERSION_MEMBER_LAUNCH_TEMPLATE_NAME, val)?;
  195    195   
        }
  196    196   
        if let Some(ref val) = self.version_number {
  197    197   
            ser.write_long(&LAUNCHTEMPLATEVERSION_MEMBER_VERSION_NUMBER, *val)?;
  198    198   
        }
  199    199   
        if let Some(ref val) = self.version_description {
  200    200   
            ser.write_string(&LAUNCHTEMPLATEVERSION_MEMBER_VERSION_DESCRIPTION, val)?;
  201    201   
        }
  202    202   
        if let Some(ref val) = self.create_time {
  203    203   
            ser.write_timestamp(&LAUNCHTEMPLATEVERSION_MEMBER_CREATE_TIME, val)?;
  204    204   
        }
  205    205   
        if let Some(ref val) = self.created_by {
  206    206   
            ser.write_string(&LAUNCHTEMPLATEVERSION_MEMBER_CREATED_BY, val)?;
  207    207   
        }
  208    208   
        if let Some(ref val) = self.default_version {
  209    209   
            ser.write_boolean(&LAUNCHTEMPLATEVERSION_MEMBER_DEFAULT_VERSION, *val)?;
  210    210   
        }
  211    211   
        if let Some(ref val) = self.launch_template_data {
  212    212   
            ser.write_struct(&LAUNCHTEMPLATEVERSION_MEMBER_LAUNCH_TEMPLATE_DATA, val)?;
  213    213   
        }
  214    214   
        if let Some(ref val) = self.operator {
  215    215   
            ser.write_struct(&LAUNCHTEMPLATEVERSION_MEMBER_OPERATOR, val)?;
  216    216   
        }
  217    217   
        Ok(())
  218    218   
    }
  219    219   
}
  220    220   
impl LaunchTemplateVersion {
  221    221   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  222         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  223         -
        deserializer: &mut D,
         222  +
    pub fn deserialize(
         223  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  224    224   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  225    225   
        #[allow(unused_variables, unused_mut)]
  226    226   
        let mut builder = Self::builder();
  227    227   
        #[allow(
  228    228   
            unused_variables,
  229    229   
            unreachable_code,
  230    230   
            clippy::single_match,
  231    231   
            clippy::match_single_binding,
  232    232   
            clippy::diverging_sub_expression
  233    233   
        )]
  234         -
        deserializer.read_struct(&LAUNCHTEMPLATEVERSION_SCHEMA, (), |_, member, deser| {
         234  +
        deserializer.read_struct(&LAUNCHTEMPLATEVERSION_SCHEMA, &mut |member, deser| {
  235    235   
            match member.member_index() {
  236    236   
                Some(0) => {
  237    237   
                    builder.launch_template_id = Some(deser.read_string(member)?);
  238    238   
                }
  239    239   
                Some(1) => {
  240    240   
                    builder.launch_template_name = Some(deser.read_string(member)?);
  241    241   
                }
  242    242   
                Some(2) => {
  243    243   
                    builder.version_number = Some(deser.read_long(member)?);
  244    244   
                }
  245    245   
                Some(3) => {
  246    246   
                    builder.version_description = Some(deser.read_string(member)?);
  247    247   
                }
  248    248   
                Some(4) => {
  249    249   
                    builder.create_time = Some(deser.read_timestamp(member)?);
  250    250   
                }
  251    251   
                Some(5) => {
  252    252   
                    builder.created_by = Some(deser.read_string(member)?);
  253    253   
                }
  254    254   
                Some(6) => {
  255    255   
                    builder.default_version = Some(deser.read_boolean(member)?);
  256    256   
                }
  257    257   
                Some(7) => {
  258    258   
                    builder.launch_template_data = Some(crate::types::ResponseLaunchTemplateData::deserialize(deser)?);
  259    259   
                }
  260    260   
                Some(8) => {
  261    261   
                    builder.operator = Some(crate::types::OperatorResponse::deserialize(deser)?);
  262    262   
                }
  263    263   
                _ => {}
  264    264   
            }
  265    265   
            Ok(())
  266    266   
        })?;
  267    267   
        Ok(builder.build())
  268    268   
    }
  269    269   
}
         270  +
impl LaunchTemplateVersion {
         271  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         272  +
    pub fn deserialize_with_response(
         273  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         274  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         275  +
        _status: u16,
         276  +
        _body: &[u8],
         277  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         278  +
        Self::deserialize(deserializer)
         279  +
    }
         280  +
}
  270    281   
impl LaunchTemplateVersion {
  271    282   
    /// Creates a new builder-style object to manufacture [`LaunchTemplateVersion`](crate::types::LaunchTemplateVersion).
  272    283   
    pub fn builder() -> crate::types::builders::LaunchTemplateVersionBuilder {
  273    284   
        crate::types::builders::LaunchTemplateVersionBuilder::default()
  274    285   
    }
  275    286   
}
  276    287   
  277    288   
/// A builder for [`LaunchTemplateVersion`](crate::types::LaunchTemplateVersion).
  278    289   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  279    290   
#[non_exhaustive]

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

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

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

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

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

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