AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045 (ignoring whitespace)

Files changed:

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

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

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

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

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

@@ -11,11 +160,171 @@
   31     31   
    "FastLaunchLaunchTemplateSpecificationResponse",
   32     32   
);
   33     33   
static FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_MEMBER_LAUNCH_TEMPLATE_ID: ::aws_smithy_schema::Schema =
   34     34   
    ::aws_smithy_schema::Schema::new_member(
   35     35   
        ::aws_smithy_schema::ShapeId::from_static(
   36     36   
            "com.amazonaws.ec2#FastLaunchLaunchTemplateSpecificationResponse$LaunchTemplateId",
   37     37   
            "com.amazonaws.ec2",
   38     38   
            "FastLaunchLaunchTemplateSpecificationResponse",
   39     39   
        ),
   40     40   
        ::aws_smithy_schema::ShapeType::String,
   41         -
        "launch_template_id",
          41  +
        "LaunchTemplateId",
   42     42   
        0,
   43     43   
    )
   44     44   
    .with_xml_name("launchTemplateId");
   45     45   
static FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_MEMBER_LAUNCH_TEMPLATE_NAME: ::aws_smithy_schema::Schema =
   46     46   
    ::aws_smithy_schema::Schema::new_member(
   47     47   
        ::aws_smithy_schema::ShapeId::from_static(
   48     48   
            "com.amazonaws.ec2#FastLaunchLaunchTemplateSpecificationResponse$LaunchTemplateName",
   49     49   
            "com.amazonaws.ec2",
   50     50   
            "FastLaunchLaunchTemplateSpecificationResponse",
   51     51   
        ),
   52     52   
        ::aws_smithy_schema::ShapeType::String,
   53         -
        "launch_template_name",
          53  +
        "LaunchTemplateName",
   54     54   
        1,
   55     55   
    )
   56     56   
    .with_xml_name("launchTemplateName");
   57     57   
static FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_MEMBER_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.ec2#FastLaunchLaunchTemplateSpecificationResponse$Version",
   60     60   
        "com.amazonaws.ec2",
   61     61   
        "FastLaunchLaunchTemplateSpecificationResponse",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::String,
   64         -
    "version",
          64  +
    "Version",
   65     65   
    2,
   66     66   
)
   67     67   
.with_xml_name("version");
   68     68   
static FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   69     69   
    FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_SCHEMA_ID,
   70     70   
    ::aws_smithy_schema::ShapeType::Structure,
   71     71   
    &[
   72     72   
        &FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_MEMBER_LAUNCH_TEMPLATE_ID,
   73     73   
        &FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_MEMBER_LAUNCH_TEMPLATE_NAME,
   74     74   
        &FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_MEMBER_VERSION,
   75     75   
    ],
   76     76   
);
   77     77   
impl FastLaunchLaunchTemplateSpecificationResponse {
   78     78   
    /// The schema for this shape.
   79     79   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_SCHEMA;
   80     80   
}
   81     81   
impl ::aws_smithy_schema::serde::SerializableStruct for FastLaunchLaunchTemplateSpecificationResponse {
   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.launch_template_id {
   88     88   
            ser.write_string(&FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_MEMBER_LAUNCH_TEMPLATE_ID, val)?;
   89     89   
        }
   90     90   
        if let Some(ref val) = self.launch_template_name {
   91     91   
            ser.write_string(&FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_MEMBER_LAUNCH_TEMPLATE_NAME, val)?;
   92     92   
        }
   93     93   
        if let Some(ref val) = self.version {
   94     94   
            ser.write_string(&FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_MEMBER_VERSION, val)?;
   95     95   
        }
   96     96   
        Ok(())
   97     97   
    }
   98     98   
}
   99     99   
impl FastLaunchLaunchTemplateSpecificationResponse {
  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(&FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_SCHEMA, (), |_, member, deser| {
         113  +
        deserializer.read_struct(&FASTLAUNCHLAUNCHTEMPLATESPECIFICATIONRESPONSE_SCHEMA, &mut |member, deser| {
  114    114   
            match member.member_index() {
  115    115   
                Some(0) => {
  116    116   
                    builder.launch_template_id = Some(deser.read_string(member)?);
  117    117   
                }
  118    118   
                Some(1) => {
  119    119   
                    builder.launch_template_name = Some(deser.read_string(member)?);
  120    120   
                }
  121    121   
                Some(2) => {
  122    122   
                    builder.version = Some(deser.read_string(member)?);
  123    123   
                }
  124    124   
                _ => {}
  125    125   
            }
  126    126   
            Ok(())
  127    127   
        })?;
  128    128   
        Ok(builder.build())
  129    129   
    }
  130    130   
}
         131  +
impl FastLaunchLaunchTemplateSpecificationResponse {
         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 FastLaunchLaunchTemplateSpecificationResponse {
  132    143   
    /// Creates a new builder-style object to manufacture [`FastLaunchLaunchTemplateSpecificationResponse`](crate::types::FastLaunchLaunchTemplateSpecificationResponse).
  133    144   
    pub fn builder() -> crate::types::builders::FastLaunchLaunchTemplateSpecificationResponseBuilder {
  134    145   
        crate::types::builders::FastLaunchLaunchTemplateSpecificationResponseBuilder::default()
  135    146   
    }
  136    147   
}
  137    148   
  138    149   
/// A builder for [`FastLaunchLaunchTemplateSpecificationResponse`](crate::types::FastLaunchLaunchTemplateSpecificationResponse).
  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/_fast_launch_snapshot_configuration_request.rs

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

@@ -1,1 +108,119 @@
   18     18   
    "com.amazonaws.ec2",
   19     19   
    "FastLaunchSnapshotConfigurationResponse",
   20     20   
);
   21     21   
static FASTLAUNCHSNAPSHOTCONFIGURATIONRESPONSE_MEMBER_TARGET_RESOURCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.ec2#FastLaunchSnapshotConfigurationResponse$TargetResourceCount",
   24     24   
        "com.amazonaws.ec2",
   25     25   
        "FastLaunchSnapshotConfigurationResponse",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Integer,
   28         -
    "target_resource_count",
          28  +
    "TargetResourceCount",
   29     29   
    0,
   30     30   
)
   31     31   
.with_xml_name("targetResourceCount");
   32     32   
static FASTLAUNCHSNAPSHOTCONFIGURATIONRESPONSE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     33   
    FASTLAUNCHSNAPSHOTCONFIGURATIONRESPONSE_SCHEMA_ID,
   34     34   
    ::aws_smithy_schema::ShapeType::Structure,
   35     35   
    &[&FASTLAUNCHSNAPSHOTCONFIGURATIONRESPONSE_MEMBER_TARGET_RESOURCE_COUNT],
   36     36   
);
   37     37   
impl FastLaunchSnapshotConfigurationResponse {
   38     38   
    /// The schema for this shape.
   39     39   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FASTLAUNCHSNAPSHOTCONFIGURATIONRESPONSE_SCHEMA;
   40     40   
}
   41     41   
impl ::aws_smithy_schema::serde::SerializableStruct for FastLaunchSnapshotConfigurationResponse {
   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.target_resource_count {
   48     48   
            ser.write_integer(&FASTLAUNCHSNAPSHOTCONFIGURATIONRESPONSE_MEMBER_TARGET_RESOURCE_COUNT, *val)?;
   49     49   
        }
   50     50   
        Ok(())
   51     51   
    }
   52     52   
}
   53     53   
impl FastLaunchSnapshotConfigurationResponse {
   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(&FASTLAUNCHSNAPSHOTCONFIGURATIONRESPONSE_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&FASTLAUNCHSNAPSHOTCONFIGURATIONRESPONSE_SCHEMA, &mut |member, deser| {
   68     68   
            match member.member_index() {
   69     69   
                Some(0) => {
   70     70   
                    builder.target_resource_count = Some(deser.read_integer(member)?);
   71     71   
                }
   72     72   
                _ => {}
   73     73   
            }
   74     74   
            Ok(())
   75     75   
        })?;
   76     76   
        Ok(builder.build())
   77     77   
    }
   78     78   
}
          79  +
impl FastLaunchSnapshotConfigurationResponse {
          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 FastLaunchSnapshotConfigurationResponse {
   80     91   
    /// Creates a new builder-style object to manufacture [`FastLaunchSnapshotConfigurationResponse`](crate::types::FastLaunchSnapshotConfigurationResponse).
   81     92   
    pub fn builder() -> crate::types::builders::FastLaunchSnapshotConfigurationResponseBuilder {
   82     93   
        crate::types::builders::FastLaunchSnapshotConfigurationResponseBuilder::default()
   83     94   
    }
   84     95   
}
   85     96   
   86     97   
/// A builder for [`FastLaunchSnapshotConfigurationResponse`](crate::types::FastLaunchSnapshotConfigurationResponse).
   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/_federated_authentication.rs

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

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

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

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

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

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

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

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

@@ -45,45 +182,182 @@
   65     65   
}
   66     66   
static FIREWALLSTATEFULRULE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FirewallStatefulRule", "com.amazonaws.ec2", "FirewallStatefulRule");
   68     68   
static FIREWALLSTATEFULRULE_MEMBER_RULE_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.ec2#FirewallStatefulRule$RuleGroupArn",
   71     71   
        "com.amazonaws.ec2",
   72     72   
        "FirewallStatefulRule",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "rule_group_arn",
          75  +
    "RuleGroupArn",
   76     76   
    0,
   77     77   
)
   78     78   
.with_xml_name("ruleGroupArn");
   79     79   
static FIREWALLSTATEFULRULE_MEMBER_SOURCES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.ec2#FirewallStatefulRule$Sources",
   82     82   
        "com.amazonaws.ec2",
   83     83   
        "FirewallStatefulRule",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::List,
   86         -
    "sources",
          86  +
    "Sources",
   87     87   
    1,
   88     88   
)
   89     89   
.with_xml_name("sourceSet");
   90     90   
static FIREWALLSTATEFULRULE_MEMBER_DESTINATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.ec2#FirewallStatefulRule$Destinations",
   93     93   
        "com.amazonaws.ec2",
   94     94   
        "FirewallStatefulRule",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::List,
   97         -
    "destinations",
          97  +
    "Destinations",
   98     98   
    2,
   99     99   
)
  100    100   
.with_xml_name("destinationSet");
  101    101   
static FIREWALLSTATEFULRULE_MEMBER_SOURCE_PORTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.ec2#FirewallStatefulRule$SourcePorts",
  104    104   
        "com.amazonaws.ec2",
  105    105   
        "FirewallStatefulRule",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::List,
  108         -
    "source_ports",
         108  +
    "SourcePorts",
  109    109   
    3,
  110    110   
)
  111    111   
.with_xml_name("sourcePortSet");
  112    112   
static FIREWALLSTATEFULRULE_MEMBER_DESTINATION_PORTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.ec2#FirewallStatefulRule$DestinationPorts",
  115    115   
        "com.amazonaws.ec2",
  116    116   
        "FirewallStatefulRule",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::List,
  119         -
    "destination_ports",
         119  +
    "DestinationPorts",
  120    120   
    4,
  121    121   
)
  122    122   
.with_xml_name("destinationPortSet");
  123    123   
static FIREWALLSTATEFULRULE_MEMBER_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.ec2#FirewallStatefulRule$Protocol",
  126    126   
        "com.amazonaws.ec2",
  127    127   
        "FirewallStatefulRule",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::String,
  130         -
    "protocol",
         130  +
    "Protocol",
  131    131   
    5,
  132    132   
)
  133    133   
.with_xml_name("protocol");
  134    134   
static FIREWALLSTATEFULRULE_MEMBER_RULE_ACTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "com.amazonaws.ec2#FirewallStatefulRule$RuleAction",
  137    137   
        "com.amazonaws.ec2",
  138    138   
        "FirewallStatefulRule",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::String,
  141         -
    "rule_action",
         141  +
    "RuleAction",
  142    142   
    6,
  143    143   
)
  144    144   
.with_xml_name("ruleAction");
  145    145   
static FIREWALLSTATEFULRULE_MEMBER_DIRECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static(
  147    147   
        "com.amazonaws.ec2#FirewallStatefulRule$Direction",
  148    148   
        "com.amazonaws.ec2",
  149    149   
        "FirewallStatefulRule",
  150    150   
    ),
  151    151   
    ::aws_smithy_schema::ShapeType::String,
  152         -
    "direction",
         152  +
    "Direction",
  153    153   
    7,
  154    154   
)
  155    155   
.with_xml_name("direction");
  156    156   
static FIREWALLSTATEFULRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  157    157   
    FIREWALLSTATEFULRULE_SCHEMA_ID,
  158    158   
    ::aws_smithy_schema::ShapeType::Structure,
  159    159   
    &[
  160    160   
        &FIREWALLSTATEFULRULE_MEMBER_RULE_GROUP_ARN,
  161    161   
        &FIREWALLSTATEFULRULE_MEMBER_SOURCES,
  162    162   
        &FIREWALLSTATEFULRULE_MEMBER_DESTINATIONS,
@@ -211,211 +355,340 @@
  231    231   
            ser.write_string(&FIREWALLSTATEFULRULE_MEMBER_RULE_ACTION, val)?;
  232    232   
        }
  233    233   
        if let Some(ref val) = self.direction {
  234    234   
            ser.write_string(&FIREWALLSTATEFULRULE_MEMBER_DIRECTION, val)?;
  235    235   
        }
  236    236   
        Ok(())
  237    237   
    }
  238    238   
}
  239    239   
impl FirewallStatefulRule {
  240    240   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  241         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  242         -
        deserializer: &mut D,
         241  +
    pub fn deserialize(
         242  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  243    243   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  244    244   
        #[allow(unused_variables, unused_mut)]
  245    245   
        let mut builder = Self::builder();
  246    246   
        #[allow(
  247    247   
            unused_variables,
  248    248   
            unreachable_code,
  249    249   
            clippy::single_match,
  250    250   
            clippy::match_single_binding,
  251    251   
            clippy::diverging_sub_expression
  252    252   
        )]
  253         -
        deserializer.read_struct(&FIREWALLSTATEFULRULE_SCHEMA, (), |_, member, deser| {
         253  +
        deserializer.read_struct(&FIREWALLSTATEFULRULE_SCHEMA, &mut |member, deser| {
  254    254   
            match member.member_index() {
  255    255   
                Some(0) => {
  256    256   
                    builder.rule_group_arn = Some(deser.read_string(member)?);
  257    257   
                }
  258    258   
                Some(1) => {
  259         -
                    builder.sources = Some({
  260         -
                        let container = if let Some(cap) = deser.container_size() {
  261         -
                            Vec::with_capacity(cap)
  262         -
                        } else {
  263         -
                            Vec::new()
  264         -
                        };
  265         -
                        deser.read_list(member, container, |mut list, deser| {
  266         -
                            list.push(deser.read_string(member)?);
  267         -
                            Ok(list)
  268         -
                        })?
  269         -
                    });
         259  +
                    builder.sources = Some(deser.read_string_list(member)?);
  270    260   
                }
  271    261   
                Some(2) => {
  272         -
                    builder.destinations = Some({
  273         -
                        let container = if let Some(cap) = deser.container_size() {
  274         -
                            Vec::with_capacity(cap)
  275         -
                        } else {
  276         -
                            Vec::new()
  277         -
                        };
  278         -
                        deser.read_list(member, container, |mut list, deser| {
  279         -
                            list.push(deser.read_string(member)?);
  280         -
                            Ok(list)
  281         -
                        })?
  282         -
                    });
         262  +
                    builder.destinations = Some(deser.read_string_list(member)?);
  283    263   
                }
  284    264   
                Some(3) => {
  285    265   
                    builder.source_ports = Some({
  286         -
                        let container = if let Some(cap) = deser.container_size() {
  287         -
                            Vec::with_capacity(cap)
  288         -
                        } else {
  289         -
                            Vec::new()
  290         -
                        };
  291         -
                        deser.read_list(member, container, |mut list, deser| {
  292         -
                            list.push(crate::types::PortRange::deserialize(deser)?);
  293         -
                            Ok(list)
  294         -
                        })?
         266  +
                        let mut container = Vec::new();
         267  +
                        deser.read_list(member, &mut |deser| {
         268  +
                            container.push(crate::types::PortRange::deserialize(deser)?);
         269  +
                            Ok(())
         270  +
                        })?;
         271  +
                        container
  295    272   
                    });
  296    273   
                }
  297    274   
                Some(4) => {
  298    275   
                    builder.destination_ports = Some({
  299         -
                        let container = if let Some(cap) = deser.container_size() {
  300         -
                            Vec::with_capacity(cap)
  301         -
                        } else {
  302         -
                            Vec::new()
  303         -
                        };
  304         -
                        deser.read_list(member, container, |mut list, deser| {
  305         -
                            list.push(crate::types::PortRange::deserialize(deser)?);
  306         -
                            Ok(list)
  307         -
                        })?
         276  +
                        let mut container = Vec::new();
         277  +
                        deser.read_list(member, &mut |deser| {
         278  +
                            container.push(crate::types::PortRange::deserialize(deser)?);
         279  +
                            Ok(())
         280  +
                        })?;
         281  +
                        container
  308    282   
                    });
  309    283   
                }
  310    284   
                Some(5) => {
  311    285   
                    builder.protocol = Some(deser.read_string(member)?);
  312    286   
                }
  313    287   
                Some(6) => {
  314    288   
                    builder.rule_action = Some(deser.read_string(member)?);
  315    289   
                }
  316    290   
                Some(7) => {
  317    291   
                    builder.direction = Some(deser.read_string(member)?);
  318    292   
                }
  319    293   
                _ => {}
  320    294   
            }
  321    295   
            Ok(())
  322    296   
        })?;
  323    297   
        Ok(builder.build())
  324    298   
    }
  325    299   
}
         300  +
impl FirewallStatefulRule {
         301  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         302  +
    pub fn deserialize_with_response(
         303  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         304  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         305  +
        _status: u16,
         306  +
        _body: &[u8],
         307  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         308  +
        Self::deserialize(deserializer)
         309  +
    }
         310  +
}
  326    311   
impl FirewallStatefulRule {
  327    312   
    /// Creates a new builder-style object to manufacture [`FirewallStatefulRule`](crate::types::FirewallStatefulRule).
  328    313   
    pub fn builder() -> crate::types::builders::FirewallStatefulRuleBuilder {
  329    314   
        crate::types::builders::FirewallStatefulRuleBuilder::default()
  330    315   
    }
  331    316   
}
  332    317   
  333    318   
/// A builder for [`FirewallStatefulRule`](crate::types::FirewallStatefulRule).
  334    319   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  335    320   
#[non_exhaustive]

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

@@ -47,47 +184,184 @@
   67     67   
}
   68     68   
static FIREWALLSTATELESSRULE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   69     69   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FirewallStatelessRule", "com.amazonaws.ec2", "FirewallStatelessRule");
   70     70   
static FIREWALLSTATELESSRULE_MEMBER_RULE_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.ec2#FirewallStatelessRule$RuleGroupArn",
   73     73   
        "com.amazonaws.ec2",
   74     74   
        "FirewallStatelessRule",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "rule_group_arn",
          77  +
    "RuleGroupArn",
   78     78   
    0,
   79     79   
)
   80     80   
.with_xml_name("ruleGroupArn");
   81     81   
static FIREWALLSTATELESSRULE_MEMBER_SOURCES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.ec2#FirewallStatelessRule$Sources",
   84     84   
        "com.amazonaws.ec2",
   85     85   
        "FirewallStatelessRule",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::List,
   88         -
    "sources",
          88  +
    "Sources",
   89     89   
    1,
   90     90   
)
   91     91   
.with_xml_name("sourceSet");
   92     92   
static FIREWALLSTATELESSRULE_MEMBER_DESTINATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "com.amazonaws.ec2#FirewallStatelessRule$Destinations",
   95     95   
        "com.amazonaws.ec2",
   96     96   
        "FirewallStatelessRule",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::List,
   99         -
    "destinations",
          99  +
    "Destinations",
  100    100   
    2,
  101    101   
)
  102    102   
.with_xml_name("destinationSet");
  103    103   
static FIREWALLSTATELESSRULE_MEMBER_SOURCE_PORTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.ec2#FirewallStatelessRule$SourcePorts",
  106    106   
        "com.amazonaws.ec2",
  107    107   
        "FirewallStatelessRule",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::List,
  110         -
    "source_ports",
         110  +
    "SourcePorts",
  111    111   
    3,
  112    112   
)
  113    113   
.with_xml_name("sourcePortSet");
  114    114   
static FIREWALLSTATELESSRULE_MEMBER_DESTINATION_PORTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "com.amazonaws.ec2#FirewallStatelessRule$DestinationPorts",
  117    117   
        "com.amazonaws.ec2",
  118    118   
        "FirewallStatelessRule",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::List,
  121         -
    "destination_ports",
         121  +
    "DestinationPorts",
  122    122   
    4,
  123    123   
)
  124    124   
.with_xml_name("destinationPortSet");
  125    125   
static FIREWALLSTATELESSRULE_MEMBER_PROTOCOLS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "com.amazonaws.ec2#FirewallStatelessRule$Protocols",
  128    128   
        "com.amazonaws.ec2",
  129    129   
        "FirewallStatelessRule",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::List,
  132         -
    "protocols",
         132  +
    "Protocols",
  133    133   
    5,
  134    134   
)
  135    135   
.with_xml_name("protocolSet");
  136    136   
static FIREWALLSTATELESSRULE_MEMBER_RULE_ACTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  137    137   
    ::aws_smithy_schema::ShapeId::from_static(
  138    138   
        "com.amazonaws.ec2#FirewallStatelessRule$RuleAction",
  139    139   
        "com.amazonaws.ec2",
  140    140   
        "FirewallStatelessRule",
  141    141   
    ),
  142    142   
    ::aws_smithy_schema::ShapeType::String,
  143         -
    "rule_action",
         143  +
    "RuleAction",
  144    144   
    6,
  145    145   
)
  146    146   
.with_xml_name("ruleAction");
  147    147   
static FIREWALLSTATELESSRULE_MEMBER_PRIORITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  148    148   
    ::aws_smithy_schema::ShapeId::from_static(
  149    149   
        "com.amazonaws.ec2#FirewallStatelessRule$Priority",
  150    150   
        "com.amazonaws.ec2",
  151    151   
        "FirewallStatelessRule",
  152    152   
    ),
  153    153   
    ::aws_smithy_schema::ShapeType::Integer,
  154         -
    "priority",
         154  +
    "Priority",
  155    155   
    7,
  156    156   
)
  157    157   
.with_xml_name("priority");
  158    158   
static FIREWALLSTATELESSRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  159    159   
    FIREWALLSTATELESSRULE_SCHEMA_ID,
  160    160   
    ::aws_smithy_schema::ShapeType::Structure,
  161    161   
    &[
  162    162   
        &FIREWALLSTATELESSRULE_MEMBER_RULE_GROUP_ARN,
  163    163   
        &FIREWALLSTATELESSRULE_MEMBER_SOURCES,
  164    164   
        &FIREWALLSTATELESSRULE_MEMBER_DESTINATIONS,
@@ -221,221 +375,350 @@
  241    241   
            ser.write_string(&FIREWALLSTATELESSRULE_MEMBER_RULE_ACTION, val)?;
  242    242   
        }
  243    243   
        if let Some(ref val) = self.priority {
  244    244   
            ser.write_integer(&FIREWALLSTATELESSRULE_MEMBER_PRIORITY, *val)?;
  245    245   
        }
  246    246   
        Ok(())
  247    247   
    }
  248    248   
}
  249    249   
impl FirewallStatelessRule {
  250    250   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  251         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  252         -
        deserializer: &mut D,
         251  +
    pub fn deserialize(
         252  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  253    253   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  254    254   
        #[allow(unused_variables, unused_mut)]
  255    255   
        let mut builder = Self::builder();
  256    256   
        #[allow(
  257    257   
            unused_variables,
  258    258   
            unreachable_code,
  259    259   
            clippy::single_match,
  260    260   
            clippy::match_single_binding,
  261    261   
            clippy::diverging_sub_expression
  262    262   
        )]
  263         -
        deserializer.read_struct(&FIREWALLSTATELESSRULE_SCHEMA, (), |_, member, deser| {
         263  +
        deserializer.read_struct(&FIREWALLSTATELESSRULE_SCHEMA, &mut |member, deser| {
  264    264   
            match member.member_index() {
  265    265   
                Some(0) => {
  266    266   
                    builder.rule_group_arn = Some(deser.read_string(member)?);
  267    267   
                }
  268    268   
                Some(1) => {
  269         -
                    builder.sources = Some({
  270         -
                        let container = if let Some(cap) = deser.container_size() {
  271         -
                            Vec::with_capacity(cap)
  272         -
                        } else {
  273         -
                            Vec::new()
  274         -
                        };
  275         -
                        deser.read_list(member, container, |mut list, deser| {
  276         -
                            list.push(deser.read_string(member)?);
  277         -
                            Ok(list)
  278         -
                        })?
  279         -
                    });
         269  +
                    builder.sources = Some(deser.read_string_list(member)?);
  280    270   
                }
  281    271   
                Some(2) => {
  282         -
                    builder.destinations = Some({
  283         -
                        let container = if let Some(cap) = deser.container_size() {
  284         -
                            Vec::with_capacity(cap)
  285         -
                        } else {
  286         -
                            Vec::new()
  287         -
                        };
  288         -
                        deser.read_list(member, container, |mut list, deser| {
  289         -
                            list.push(deser.read_string(member)?);
  290         -
                            Ok(list)
  291         -
                        })?
  292         -
                    });
         272  +
                    builder.destinations = Some(deser.read_string_list(member)?);
  293    273   
                }
  294    274   
                Some(3) => {
  295    275   
                    builder.source_ports = Some({
  296         -
                        let container = if let Some(cap) = deser.container_size() {
  297         -
                            Vec::with_capacity(cap)
  298         -
                        } else {
  299         -
                            Vec::new()
  300         -
                        };
  301         -
                        deser.read_list(member, container, |mut list, deser| {
  302         -
                            list.push(crate::types::PortRange::deserialize(deser)?);
  303         -
                            Ok(list)
  304         -
                        })?
         276  +
                        let mut container = Vec::new();
         277  +
                        deser.read_list(member, &mut |deser| {
         278  +
                            container.push(crate::types::PortRange::deserialize(deser)?);
         279  +
                            Ok(())
         280  +
                        })?;
         281  +
                        container
  305    282   
                    });
  306    283   
                }
  307    284   
                Some(4) => {
  308    285   
                    builder.destination_ports = Some({
  309         -
                        let container = if let Some(cap) = deser.container_size() {
  310         -
                            Vec::with_capacity(cap)
  311         -
                        } else {
  312         -
                            Vec::new()
  313         -
                        };
  314         -
                        deser.read_list(member, container, |mut list, deser| {
  315         -
                            list.push(crate::types::PortRange::deserialize(deser)?);
  316         -
                            Ok(list)
  317         -
                        })?
         286  +
                        let mut container = Vec::new();
         287  +
                        deser.read_list(member, &mut |deser| {
         288  +
                            container.push(crate::types::PortRange::deserialize(deser)?);
         289  +
                            Ok(())
         290  +
                        })?;
         291  +
                        container
  318    292   
                    });
  319    293   
                }
  320    294   
                Some(5) => {
  321         -
                    builder.protocols = Some({
  322         -
                        let container = if let Some(cap) = deser.container_size() {
  323         -
                            Vec::with_capacity(cap)
  324         -
                        } else {
  325         -
                            Vec::new()
  326         -
                        };
  327         -
                        deser.read_list(member, container, |mut list, deser| {
  328         -
                            list.push(deser.read_integer(member)?);
  329         -
                            Ok(list)
  330         -
                        })?
  331         -
                    });
         295  +
                    builder.protocols = Some(deser.read_integer_list(member)?);
  332    296   
                }
  333    297   
                Some(6) => {
  334    298   
                    builder.rule_action = Some(deser.read_string(member)?);
  335    299   
                }
  336    300   
                Some(7) => {
  337    301   
                    builder.priority = Some(deser.read_integer(member)?);
  338    302   
                }
  339    303   
                _ => {}
  340    304   
            }
  341    305   
            Ok(())
  342    306   
        })?;
  343    307   
        Ok(builder.build())
  344    308   
    }
  345    309   
}
         310  +
impl FirewallStatelessRule {
         311  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         312  +
    pub fn deserialize_with_response(
         313  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         314  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         315  +
        _status: u16,
         316  +
        _body: &[u8],
         317  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         318  +
        Self::deserialize(deserializer)
         319  +
    }
         320  +
}
  346    321   
impl FirewallStatelessRule {
  347    322   
    /// Creates a new builder-style object to manufacture [`FirewallStatelessRule`](crate::types::FirewallStatelessRule).
  348    323   
    pub fn builder() -> crate::types::builders::FirewallStatelessRuleBuilder {
  349    324   
        crate::types::builders::FirewallStatelessRuleBuilder::default()
  350    325   
    }
  351    326   
}
  352    327   
  353    328   
/// A builder for [`FirewallStatelessRule`](crate::types::FirewallStatelessRule).
  354    329   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  355    330   
#[non_exhaustive]

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

@@ -36,36 +198,209 @@
   56     56   
    "com.amazonaws.ec2",
   57     57   
    "FleetBlockDeviceMappingRequest",
   58     58   
);
   59     59   
static FLEETBLOCKDEVICEMAPPINGREQUEST_MEMBER_DEVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.ec2#FleetBlockDeviceMappingRequest$DeviceName",
   62     62   
        "com.amazonaws.ec2",
   63     63   
        "FleetBlockDeviceMappingRequest",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "device_name",
          66  +
    "DeviceName",
   67     67   
    0,
   68     68   
);
   69     69   
static FLEETBLOCKDEVICEMAPPINGREQUEST_MEMBER_VIRTUAL_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.ec2#FleetBlockDeviceMappingRequest$VirtualName",
   72     72   
        "com.amazonaws.ec2",
   73     73   
        "FleetBlockDeviceMappingRequest",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "virtual_name",
          76  +
    "VirtualName",
   77     77   
    1,
   78     78   
);
   79     79   
static FLEETBLOCKDEVICEMAPPINGREQUEST_MEMBER_EBS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.ec2#FleetBlockDeviceMappingRequest$Ebs",
   82     82   
        "com.amazonaws.ec2",
   83     83   
        "FleetBlockDeviceMappingRequest",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86         -
    "ebs",
          86  +
    "Ebs",
   87     87   
    2,
   88     88   
);
   89     89   
static FLEETBLOCKDEVICEMAPPINGREQUEST_MEMBER_NO_DEVICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.ec2#FleetBlockDeviceMappingRequest$NoDevice",
   92     92   
        "com.amazonaws.ec2",
   93     93   
        "FleetBlockDeviceMappingRequest",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::String,
   96         -
    "no_device",
          96  +
    "NoDevice",
   97     97   
    3,
   98     98   
);
   99     99   
static FLEETBLOCKDEVICEMAPPINGREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  100    100   
    FLEETBLOCKDEVICEMAPPINGREQUEST_SCHEMA_ID,
  101    101   
    ::aws_smithy_schema::ShapeType::Structure,
  102    102   
    &[
  103    103   
        &FLEETBLOCKDEVICEMAPPINGREQUEST_MEMBER_DEVICE_NAME,
  104    104   
        &FLEETBLOCKDEVICEMAPPINGREQUEST_MEMBER_VIRTUAL_NAME,
  105    105   
        &FLEETBLOCKDEVICEMAPPINGREQUEST_MEMBER_EBS,
  106    106   
        &FLEETBLOCKDEVICEMAPPINGREQUEST_MEMBER_NO_DEVICE,
  107    107   
    ],
  108    108   
);
  109    109   
impl FleetBlockDeviceMappingRequest {
  110    110   
    /// The schema for this shape.
  111    111   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLEETBLOCKDEVICEMAPPINGREQUEST_SCHEMA;
  112    112   
}
  113    113   
impl ::aws_smithy_schema::serde::SerializableStruct for FleetBlockDeviceMappingRequest {
  114    114   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  115    115   
    fn serialize_members(
  116    116   
        &self,
  117    117   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  118    118   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  119    119   
        if let Some(ref val) = self.device_name {
  120    120   
            ser.write_string(&FLEETBLOCKDEVICEMAPPINGREQUEST_MEMBER_DEVICE_NAME, val)?;
  121    121   
        }
  122    122   
        if let Some(ref val) = self.virtual_name {
  123    123   
            ser.write_string(&FLEETBLOCKDEVICEMAPPINGREQUEST_MEMBER_VIRTUAL_NAME, val)?;
  124    124   
        }
  125    125   
        if let Some(ref val) = self.ebs {
  126    126   
            ser.write_struct(&FLEETBLOCKDEVICEMAPPINGREQUEST_MEMBER_EBS, val)?;
  127    127   
        }
  128    128   
        if let Some(ref val) = self.no_device {
  129    129   
            ser.write_string(&FLEETBLOCKDEVICEMAPPINGREQUEST_MEMBER_NO_DEVICE, val)?;
  130    130   
        }
  131    131   
        Ok(())
  132    132   
    }
  133    133   
}
  134    134   
impl FleetBlockDeviceMappingRequest {
  135    135   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  136         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  137         -
        deserializer: &mut D,
         136  +
    pub fn deserialize(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  138    138   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  139    139   
        #[allow(unused_variables, unused_mut)]
  140    140   
        let mut builder = Self::builder();
  141    141   
        #[allow(
  142    142   
            unused_variables,
  143    143   
            unreachable_code,
  144    144   
            clippy::single_match,
  145    145   
            clippy::match_single_binding,
  146    146   
            clippy::diverging_sub_expression
  147    147   
        )]
  148         -
        deserializer.read_struct(&FLEETBLOCKDEVICEMAPPINGREQUEST_SCHEMA, (), |_, member, deser| {
         148  +
        deserializer.read_struct(&FLEETBLOCKDEVICEMAPPINGREQUEST_SCHEMA, &mut |member, deser| {
  149    149   
            match member.member_index() {
  150    150   
                Some(0) => {
  151    151   
                    builder.device_name = Some(deser.read_string(member)?);
  152    152   
                }
  153    153   
                Some(1) => {
  154    154   
                    builder.virtual_name = Some(deser.read_string(member)?);
  155    155   
                }
  156    156   
                Some(2) => {
  157    157   
                    builder.ebs = Some(crate::types::FleetEbsBlockDeviceRequest::deserialize(deser)?);
  158    158   
                }
  159    159   
                Some(3) => {
  160    160   
                    builder.no_device = Some(deser.read_string(member)?);
  161    161   
                }
  162    162   
                _ => {}
  163    163   
            }
  164    164   
            Ok(())
  165    165   
        })?;
  166    166   
        Ok(builder.build())
  167    167   
    }
  168    168   
}
         169  +
impl FleetBlockDeviceMappingRequest {
         170  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         171  +
    pub fn deserialize_with_response(
         172  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         173  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         174  +
        _status: u16,
         175  +
        _body: &[u8],
         176  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         177  +
        Self::deserialize(deserializer)
         178  +
    }
         179  +
}
  169    180   
impl FleetBlockDeviceMappingRequest {
  170    181   
    /// Creates a new builder-style object to manufacture [`FleetBlockDeviceMappingRequest`](crate::types::FleetBlockDeviceMappingRequest).
  171    182   
    pub fn builder() -> crate::types::builders::FleetBlockDeviceMappingRequestBuilder {
  172    183   
        crate::types::builders::FleetBlockDeviceMappingRequestBuilder::default()
  173    184   
    }
  174    185   
}
  175    186   
  176    187   
/// A builder for [`FleetBlockDeviceMappingRequest`](crate::types::FleetBlockDeviceMappingRequest).
  177    188   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  178    189   
#[non_exhaustive]

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

@@ -58,58 +228,228 @@
   78     78   
    "com.amazonaws.ec2",
   79     79   
    "FleetCapacityReservation",
   80     80   
);
   81     81   
static FLEETCAPACITYRESERVATION_MEMBER_CAPACITY_RESERVATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.ec2#FleetCapacityReservation$CapacityReservationId",
   84     84   
        "com.amazonaws.ec2",
   85     85   
        "FleetCapacityReservation",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::String,
   88         -
    "capacity_reservation_id",
          88  +
    "CapacityReservationId",
   89     89   
    0,
   90     90   
)
   91     91   
.with_xml_name("capacityReservationId");
   92     92   
static FLEETCAPACITYRESERVATION_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "com.amazonaws.ec2#FleetCapacityReservation$AvailabilityZoneId",
   95     95   
        "com.amazonaws.ec2",
   96     96   
        "FleetCapacityReservation",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "availability_zone_id",
          99  +
    "AvailabilityZoneId",
  100    100   
    1,
  101    101   
)
  102    102   
.with_xml_name("availabilityZoneId");
  103    103   
static FLEETCAPACITYRESERVATION_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.ec2#FleetCapacityReservation$InstanceType",
  106    106   
        "com.amazonaws.ec2",
  107    107   
        "FleetCapacityReservation",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::String,
  110         -
    "instance_type",
         110  +
    "InstanceType",
  111    111   
    2,
  112    112   
)
  113    113   
.with_xml_name("instanceType");
  114    114   
static FLEETCAPACITYRESERVATION_MEMBER_INSTANCE_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "com.amazonaws.ec2#FleetCapacityReservation$InstancePlatform",
  117    117   
        "com.amazonaws.ec2",
  118    118   
        "FleetCapacityReservation",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::String,
  121         -
    "instance_platform",
         121  +
    "InstancePlatform",
  122    122   
    3,
  123    123   
)
  124    124   
.with_xml_name("instancePlatform");
  125    125   
static FLEETCAPACITYRESERVATION_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "com.amazonaws.ec2#FleetCapacityReservation$AvailabilityZone",
  128    128   
        "com.amazonaws.ec2",
  129    129   
        "FleetCapacityReservation",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::String,
  132         -
    "availability_zone",
         132  +
    "AvailabilityZone",
  133    133   
    4,
  134    134   
)
  135    135   
.with_xml_name("availabilityZone");
  136    136   
static FLEETCAPACITYRESERVATION_MEMBER_TOTAL_INSTANCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  137    137   
    ::aws_smithy_schema::ShapeId::from_static(
  138    138   
        "com.amazonaws.ec2#FleetCapacityReservation$TotalInstanceCount",
  139    139   
        "com.amazonaws.ec2",
  140    140   
        "FleetCapacityReservation",
  141    141   
    ),
  142    142   
    ::aws_smithy_schema::ShapeType::Integer,
  143         -
    "total_instance_count",
         143  +
    "TotalInstanceCount",
  144    144   
    5,
  145    145   
)
  146    146   
.with_xml_name("totalInstanceCount");
  147    147   
static FLEETCAPACITYRESERVATION_MEMBER_FULFILLED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  148    148   
    ::aws_smithy_schema::ShapeId::from_static(
  149    149   
        "com.amazonaws.ec2#FleetCapacityReservation$FulfilledCapacity",
  150    150   
        "com.amazonaws.ec2",
  151    151   
        "FleetCapacityReservation",
  152    152   
    ),
  153    153   
    ::aws_smithy_schema::ShapeType::Double,
  154         -
    "fulfilled_capacity",
         154  +
    "FulfilledCapacity",
  155    155   
    6,
  156    156   
)
  157    157   
.with_xml_name("fulfilledCapacity");
  158    158   
static FLEETCAPACITYRESERVATION_MEMBER_EBS_OPTIMIZED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  159    159   
    ::aws_smithy_schema::ShapeId::from_static(
  160    160   
        "com.amazonaws.ec2#FleetCapacityReservation$EbsOptimized",
  161    161   
        "com.amazonaws.ec2",
  162    162   
        "FleetCapacityReservation",
  163    163   
    ),
  164    164   
    ::aws_smithy_schema::ShapeType::Boolean,
  165         -
    "ebs_optimized",
         165  +
    "EbsOptimized",
  166    166   
    7,
  167    167   
)
  168    168   
.with_xml_name("ebsOptimized");
  169    169   
static FLEETCAPACITYRESERVATION_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  170    170   
    ::aws_smithy_schema::ShapeId::from_static(
  171    171   
        "com.amazonaws.ec2#FleetCapacityReservation$CreateDate",
  172    172   
        "com.amazonaws.ec2",
  173    173   
        "FleetCapacityReservation",
  174    174   
    ),
  175    175   
    ::aws_smithy_schema::ShapeType::Timestamp,
  176         -
    "create_date",
         176  +
    "CreateDate",
  177    177   
    8,
  178    178   
)
  179    179   
.with_xml_name("createDate");
  180    180   
static FLEETCAPACITYRESERVATION_MEMBER_WEIGHT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  181    181   
    ::aws_smithy_schema::ShapeId::from_static(
  182    182   
        "com.amazonaws.ec2#FleetCapacityReservation$Weight",
  183    183   
        "com.amazonaws.ec2",
  184    184   
        "FleetCapacityReservation",
  185    185   
    ),
  186    186   
    ::aws_smithy_schema::ShapeType::Double,
  187         -
    "weight",
         187  +
    "Weight",
  188    188   
    9,
  189    189   
)
  190    190   
.with_xml_name("weight");
  191    191   
static FLEETCAPACITYRESERVATION_MEMBER_PRIORITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  192    192   
    ::aws_smithy_schema::ShapeId::from_static(
  193    193   
        "com.amazonaws.ec2#FleetCapacityReservation$Priority",
  194    194   
        "com.amazonaws.ec2",
  195    195   
        "FleetCapacityReservation",
  196    196   
    ),
  197    197   
    ::aws_smithy_schema::ShapeType::Integer,
  198         -
    "priority",
         198  +
    "Priority",
  199    199   
    10,
  200    200   
)
  201    201   
.with_xml_name("priority");
  202    202   
static FLEETCAPACITYRESERVATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  203    203   
    FLEETCAPACITYRESERVATION_SCHEMA_ID,
  204    204   
    ::aws_smithy_schema::ShapeType::Structure,
  205    205   
    &[
  206    206   
        &FLEETCAPACITYRESERVATION_MEMBER_CAPACITY_RESERVATION_ID,
  207    207   
        &FLEETCAPACITYRESERVATION_MEMBER_AVAILABILITY_ZONE_ID,
  208    208   
        &FLEETCAPACITYRESERVATION_MEMBER_INSTANCE_TYPE,
@@ -237,237 +352,363 @@
  257    257   
            ser.write_double(&FLEETCAPACITYRESERVATION_MEMBER_WEIGHT, *val)?;
  258    258   
        }
  259    259   
        if let Some(ref val) = self.priority {
  260    260   
            ser.write_integer(&FLEETCAPACITYRESERVATION_MEMBER_PRIORITY, *val)?;
  261    261   
        }
  262    262   
        Ok(())
  263    263   
    }
  264    264   
}
  265    265   
impl FleetCapacityReservation {
  266    266   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  267         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  268         -
        deserializer: &mut D,
         267  +
    pub fn deserialize(
         268  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  269    269   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  270    270   
        #[allow(unused_variables, unused_mut)]
  271    271   
        let mut builder = Self::builder();
  272    272   
        #[allow(
  273    273   
            unused_variables,
  274    274   
            unreachable_code,
  275    275   
            clippy::single_match,
  276    276   
            clippy::match_single_binding,
  277    277   
            clippy::diverging_sub_expression
  278    278   
        )]
  279         -
        deserializer.read_struct(&FLEETCAPACITYRESERVATION_SCHEMA, (), |_, member, deser| {
         279  +
        deserializer.read_struct(&FLEETCAPACITYRESERVATION_SCHEMA, &mut |member, deser| {
  280    280   
            match member.member_index() {
  281    281   
                Some(0) => {
  282    282   
                    builder.capacity_reservation_id = Some(deser.read_string(member)?);
  283    283   
                }
  284    284   
                Some(1) => {
  285    285   
                    builder.availability_zone_id = Some(deser.read_string(member)?);
  286    286   
                }
  287    287   
                Some(2) => {
  288    288   
                    builder.instance_type = Some(crate::types::InstanceType::from(deser.read_string(member)?.as_str()));
  289    289   
                }
  290    290   
                Some(3) => {
  291    291   
                    builder.instance_platform = Some(crate::types::CapacityReservationInstancePlatform::from(
  292    292   
                        deser.read_string(member)?.as_str(),
  293    293   
                    ));
  294    294   
                }
  295    295   
                Some(4) => {
  296    296   
                    builder.availability_zone = Some(deser.read_string(member)?);
  297    297   
                }
  298    298   
                Some(5) => {
  299    299   
                    builder.total_instance_count = Some(deser.read_integer(member)?);
  300    300   
                }
  301    301   
                Some(6) => {
  302    302   
                    builder.fulfilled_capacity = Some(deser.read_double(member)?);
  303    303   
                }
  304    304   
                Some(7) => {
  305    305   
                    builder.ebs_optimized = Some(deser.read_boolean(member)?);
  306    306   
                }
  307    307   
                Some(8) => {
  308    308   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  309    309   
                }
  310    310   
                Some(9) => {
  311    311   
                    builder.weight = Some(deser.read_double(member)?);
  312    312   
                }
  313    313   
                Some(10) => {
  314    314   
                    builder.priority = Some(deser.read_integer(member)?);
  315    315   
                }
  316    316   
                _ => {}
  317    317   
            }
  318    318   
            Ok(())
  319    319   
        })?;
  320    320   
        Ok(builder.build())
  321    321   
    }
  322    322   
}
         323  +
impl FleetCapacityReservation {
         324  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         325  +
    pub fn deserialize_with_response(
         326  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         327  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         328  +
        _status: u16,
         329  +
        _body: &[u8],
         330  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         331  +
        Self::deserialize(deserializer)
         332  +
    }
         333  +
}
  323    334   
impl FleetCapacityReservation {
  324    335   
    /// Creates a new builder-style object to manufacture [`FleetCapacityReservation`](crate::types::FleetCapacityReservation).
  325    336   
    pub fn builder() -> crate::types::builders::FleetCapacityReservationBuilder {
  326    337   
        crate::types::builders::FleetCapacityReservationBuilder::default()
  327    338   
    }
  328    339   
}
  329    340   
  330    341   
/// A builder for [`FleetCapacityReservation`](crate::types::FleetCapacityReservation).
  331    342   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  332    343   
#[non_exhaustive]

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

@@ -127,127 +339,339 @@
  147    147   
    /// <p>Reserved.</p>
  148    148   
    pub fn context(&self) -> ::std::option::Option<&str> {
  149    149   
        self.context.as_deref()
  150    150   
    }
  151    151   
}
  152    152   
static FLEETDATA_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  153    153   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData", "com.amazonaws.ec2", "FleetData");
  154    154   
static FLEETDATA_MEMBER_ACTIVITY_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  155    155   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$ActivityStatus", "com.amazonaws.ec2", "FleetData"),
  156    156   
    ::aws_smithy_schema::ShapeType::String,
  157         -
    "activity_status",
         157  +
    "ActivityStatus",
  158    158   
    0,
  159    159   
)
  160    160   
.with_xml_name("activityStatus");
  161    161   
static FLEETDATA_MEMBER_CREATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  162    162   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$CreateTime", "com.amazonaws.ec2", "FleetData"),
  163    163   
    ::aws_smithy_schema::ShapeType::Timestamp,
  164         -
    "create_time",
         164  +
    "CreateTime",
  165    165   
    1,
  166    166   
)
  167    167   
.with_xml_name("createTime");
  168    168   
static FLEETDATA_MEMBER_FLEET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  169    169   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$FleetId", "com.amazonaws.ec2", "FleetData"),
  170    170   
    ::aws_smithy_schema::ShapeType::String,
  171         -
    "fleet_id",
         171  +
    "FleetId",
  172    172   
    2,
  173    173   
)
  174    174   
.with_xml_name("fleetId");
  175    175   
static FLEETDATA_MEMBER_FLEET_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  176    176   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$FleetState", "com.amazonaws.ec2", "FleetData"),
  177    177   
    ::aws_smithy_schema::ShapeType::String,
  178         -
    "fleet_state",
         178  +
    "FleetState",
  179    179   
    3,
  180    180   
)
  181    181   
.with_xml_name("fleetState");
  182    182   
static FLEETDATA_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  183    183   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$ClientToken", "com.amazonaws.ec2", "FleetData"),
  184    184   
    ::aws_smithy_schema::ShapeType::String,
  185         -
    "client_token",
         185  +
    "ClientToken",
  186    186   
    4,
  187    187   
)
  188    188   
.with_xml_name("clientToken");
  189    189   
static FLEETDATA_MEMBER_EXCESS_CAPACITY_TERMINATION_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  190    190   
    ::aws_smithy_schema::ShapeId::from_static(
  191    191   
        "com.amazonaws.ec2#FleetData$ExcessCapacityTerminationPolicy",
  192    192   
        "com.amazonaws.ec2",
  193    193   
        "FleetData",
  194    194   
    ),
  195    195   
    ::aws_smithy_schema::ShapeType::String,
  196         -
    "excess_capacity_termination_policy",
         196  +
    "ExcessCapacityTerminationPolicy",
  197    197   
    5,
  198    198   
)
  199    199   
.with_xml_name("excessCapacityTerminationPolicy");
  200    200   
static FLEETDATA_MEMBER_FULFILLED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  201    201   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$FulfilledCapacity", "com.amazonaws.ec2", "FleetData"),
  202    202   
    ::aws_smithy_schema::ShapeType::Double,
  203         -
    "fulfilled_capacity",
         203  +
    "FulfilledCapacity",
  204    204   
    6,
  205    205   
)
  206    206   
.with_xml_name("fulfilledCapacity");
  207    207   
static FLEETDATA_MEMBER_FULFILLED_ON_DEMAND_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  208    208   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$FulfilledOnDemandCapacity", "com.amazonaws.ec2", "FleetData"),
  209    209   
    ::aws_smithy_schema::ShapeType::Double,
  210         -
    "fulfilled_on_demand_capacity",
         210  +
    "FulfilledOnDemandCapacity",
  211    211   
    7,
  212    212   
)
  213    213   
.with_xml_name("fulfilledOnDemandCapacity");
  214    214   
static FLEETDATA_MEMBER_LAUNCH_TEMPLATE_CONFIGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  215    215   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$LaunchTemplateConfigs", "com.amazonaws.ec2", "FleetData"),
  216    216   
    ::aws_smithy_schema::ShapeType::List,
  217         -
    "launch_template_configs",
         217  +
    "LaunchTemplateConfigs",
  218    218   
    8,
  219    219   
)
  220    220   
.with_xml_name("launchTemplateConfigs");
  221    221   
static FLEETDATA_MEMBER_TARGET_CAPACITY_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  222    222   
    ::aws_smithy_schema::ShapeId::from_static(
  223    223   
        "com.amazonaws.ec2#FleetData$TargetCapacitySpecification",
  224    224   
        "com.amazonaws.ec2",
  225    225   
        "FleetData",
  226    226   
    ),
  227    227   
    ::aws_smithy_schema::ShapeType::Structure,
  228         -
    "target_capacity_specification",
         228  +
    "TargetCapacitySpecification",
  229    229   
    9,
  230    230   
)
  231    231   
.with_xml_name("targetCapacitySpecification");
  232    232   
static FLEETDATA_MEMBER_TERMINATE_INSTANCES_WITH_EXPIRATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  233    233   
    ::aws_smithy_schema::ShapeId::from_static(
  234    234   
        "com.amazonaws.ec2#FleetData$TerminateInstancesWithExpiration",
  235    235   
        "com.amazonaws.ec2",
  236    236   
        "FleetData",
  237    237   
    ),
  238    238   
    ::aws_smithy_schema::ShapeType::Boolean,
  239         -
    "terminate_instances_with_expiration",
         239  +
    "TerminateInstancesWithExpiration",
  240    240   
    10,
  241    241   
)
  242    242   
.with_xml_name("terminateInstancesWithExpiration");
  243    243   
static FLEETDATA_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  244    244   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$Type", "com.amazonaws.ec2", "FleetData"),
  245    245   
    ::aws_smithy_schema::ShapeType::String,
  246         -
    "r##type",
         246  +
    "Type",
  247    247   
    11,
  248    248   
)
  249    249   
.with_xml_name("type");
  250    250   
static FLEETDATA_MEMBER_VALID_FROM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  251    251   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$ValidFrom", "com.amazonaws.ec2", "FleetData"),
  252    252   
    ::aws_smithy_schema::ShapeType::Timestamp,
  253         -
    "valid_from",
         253  +
    "ValidFrom",
  254    254   
    12,
  255    255   
)
  256    256   
.with_xml_name("validFrom");
  257    257   
static FLEETDATA_MEMBER_VALID_UNTIL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  258    258   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$ValidUntil", "com.amazonaws.ec2", "FleetData"),
  259    259   
    ::aws_smithy_schema::ShapeType::Timestamp,
  260         -
    "valid_until",
         260  +
    "ValidUntil",
  261    261   
    13,
  262    262   
)
  263    263   
.with_xml_name("validUntil");
  264    264   
static FLEETDATA_MEMBER_REPLACE_UNHEALTHY_INSTANCES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  265    265   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$ReplaceUnhealthyInstances", "com.amazonaws.ec2", "FleetData"),
  266    266   
    ::aws_smithy_schema::ShapeType::Boolean,
  267         -
    "replace_unhealthy_instances",
         267  +
    "ReplaceUnhealthyInstances",
  268    268   
    14,
  269    269   
)
  270    270   
.with_xml_name("replaceUnhealthyInstances");
  271    271   
static FLEETDATA_MEMBER_SPOT_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  272    272   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$SpotOptions", "com.amazonaws.ec2", "FleetData"),
  273    273   
    ::aws_smithy_schema::ShapeType::Structure,
  274         -
    "spot_options",
         274  +
    "SpotOptions",
  275    275   
    15,
  276    276   
)
  277    277   
.with_xml_name("spotOptions");
  278    278   
static FLEETDATA_MEMBER_ON_DEMAND_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  279    279   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$OnDemandOptions", "com.amazonaws.ec2", "FleetData"),
  280    280   
    ::aws_smithy_schema::ShapeType::Structure,
  281         -
    "on_demand_options",
         281  +
    "OnDemandOptions",
  282    282   
    16,
  283    283   
)
  284    284   
.with_xml_name("onDemandOptions");
  285    285   
static FLEETDATA_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  286    286   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$Tags", "com.amazonaws.ec2", "FleetData"),
  287    287   
    ::aws_smithy_schema::ShapeType::List,
  288         -
    "tags",
         288  +
    "Tags",
  289    289   
    17,
  290    290   
)
  291    291   
.with_xml_name("tagSet");
  292    292   
static FLEETDATA_MEMBER_ERRORS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  293    293   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$Errors", "com.amazonaws.ec2", "FleetData"),
  294    294   
    ::aws_smithy_schema::ShapeType::List,
  295         -
    "errors",
         295  +
    "Errors",
  296    296   
    18,
  297    297   
)
  298    298   
.with_xml_name("errorSet");
  299    299   
static FLEETDATA_MEMBER_INSTANCES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  300    300   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$Instances", "com.amazonaws.ec2", "FleetData"),
  301    301   
    ::aws_smithy_schema::ShapeType::List,
  302         -
    "instances",
         302  +
    "Instances",
  303    303   
    19,
  304    304   
)
  305    305   
.with_xml_name("fleetInstanceSet");
  306    306   
static FLEETDATA_MEMBER_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  307    307   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#FleetData$Context", "com.amazonaws.ec2", "FleetData"),
  308    308   
    ::aws_smithy_schema::ShapeType::String,
  309         -
    "context",
         309  +
    "Context",
  310    310   
    20,
  311    311   
)
  312    312   
.with_xml_name("context");
  313    313   
static FLEETDATA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  314    314   
    FLEETDATA_SCHEMA_ID,
  315    315   
    ::aws_smithy_schema::ShapeType::Structure,
  316    316   
    &[
  317    317   
        &FLEETDATA_MEMBER_ACTIVITY_STATUS,
  318    318   
        &FLEETDATA_MEMBER_CREATE_TIME,
  319    319   
        &FLEETDATA_MEMBER_FLEET_ID,
@@ -414,414 +599,598 @@
  434    434   
            )?;
  435    435   
        }
  436    436   
        if let Some(ref val) = self.context {
  437    437   
            ser.write_string(&FLEETDATA_MEMBER_CONTEXT, val)?;
  438    438   
        }
  439    439   
        Ok(())
  440    440   
    }
  441    441   
}
  442    442   
impl FleetData {
  443    443   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  444         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  445         -
        deserializer: &mut D,
         444  +
    pub fn deserialize(
         445  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  446    446   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  447    447   
        #[allow(unused_variables, unused_mut)]
  448    448   
        let mut builder = Self::builder();
  449    449   
        #[allow(
  450    450   
            unused_variables,
  451    451   
            unreachable_code,
  452    452   
            clippy::single_match,
  453    453   
            clippy::match_single_binding,
  454    454   
            clippy::diverging_sub_expression
  455    455   
        )]
  456         -
        deserializer.read_struct(&FLEETDATA_SCHEMA, (), |_, member, deser| {
         456  +
        deserializer.read_struct(&FLEETDATA_SCHEMA, &mut |member, deser| {
  457    457   
            match member.member_index() {
  458    458   
                Some(0) => {
  459    459   
                    builder.activity_status = Some(crate::types::FleetActivityStatus::from(deser.read_string(member)?.as_str()));
  460    460   
                }
  461    461   
                Some(1) => {
  462    462   
                    builder.create_time = Some(deser.read_timestamp(member)?);
  463    463   
                }
  464    464   
                Some(2) => {
  465    465   
                    builder.fleet_id = Some(deser.read_string(member)?);
  466    466   
                }
  467    467   
                Some(3) => {
  468    468   
                    builder.fleet_state = Some(crate::types::FleetStateCode::from(deser.read_string(member)?.as_str()));
  469    469   
                }
  470    470   
                Some(4) => {
  471    471   
                    builder.client_token = Some(deser.read_string(member)?);
  472    472   
                }
  473    473   
                Some(5) => {
  474    474   
                    builder.excess_capacity_termination_policy = Some(crate::types::FleetExcessCapacityTerminationPolicy::from(
  475    475   
                        deser.read_string(member)?.as_str(),
  476    476   
                    ));
  477    477   
                }
  478    478   
                Some(6) => {
  479    479   
                    builder.fulfilled_capacity = Some(deser.read_double(member)?);
  480    480   
                }
  481    481   
                Some(7) => {
  482    482   
                    builder.fulfilled_on_demand_capacity = Some(deser.read_double(member)?);
  483    483   
                }
  484    484   
                Some(8) => {
  485    485   
                    builder.launch_template_configs = Some({
  486         -
                        let container = if let Some(cap) = deser.container_size() {
  487         -
                            Vec::with_capacity(cap)
  488         -
                        } else {
  489         -
                            Vec::new()
  490         -
                        };
  491         -
                        deser.read_list(member, container, |mut list, deser| {
  492         -
                            list.push(crate::types::FleetLaunchTemplateConfig::deserialize(deser)?);
  493         -
                            Ok(list)
  494         -
                        })?
         486  +
                        let mut container = Vec::new();
         487  +
                        deser.read_list(member, &mut |deser| {
         488  +
                            container.push(crate::types::FleetLaunchTemplateConfig::deserialize(deser)?);
         489  +
                            Ok(())
         490  +
                        })?;
         491  +
                        container
  495    492   
                    });
  496    493   
                }
  497    494   
                Some(9) => {
  498    495   
                    builder.target_capacity_specification = Some(crate::types::TargetCapacitySpecification::deserialize(deser)?);
  499    496   
                }
  500    497   
                Some(10) => {
  501    498   
                    builder.terminate_instances_with_expiration = Some(deser.read_boolean(member)?);
  502    499   
                }
  503    500   
                Some(11) => {
  504    501   
                    builder.r#type = Some(crate::types::FleetType::from(deser.read_string(member)?.as_str()));
  505    502   
                }
  506    503   
                Some(12) => {
  507    504   
                    builder.valid_from = Some(deser.read_timestamp(member)?);
  508    505   
                }
  509    506   
                Some(13) => {
  510    507   
                    builder.valid_until = Some(deser.read_timestamp(member)?);
  511    508   
                }
  512    509   
                Some(14) => {
  513    510   
                    builder.replace_unhealthy_instances = Some(deser.read_boolean(member)?);
  514    511   
                }
  515    512   
                Some(15) => {
  516    513   
                    builder.spot_options = Some(crate::types::SpotOptions::deserialize(deser)?);
  517    514   
                }
  518    515   
                Some(16) => {
  519    516   
                    builder.on_demand_options = Some(crate::types::OnDemandOptions::deserialize(deser)?);
  520    517   
                }
  521    518   
                Some(17) => {
  522    519   
                    builder.tags = Some({
  523         -
                        let container = if let Some(cap) = deser.container_size() {
  524         -
                            Vec::with_capacity(cap)
  525         -
                        } else {
  526         -
                            Vec::new()
  527         -
                        };
  528         -
                        deser.read_list(member, container, |mut list, deser| {
  529         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  530         -
                            Ok(list)
  531         -
                        })?
         520  +
                        let mut container = Vec::new();
         521  +
                        deser.read_list(member, &mut |deser| {
         522  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         523  +
                            Ok(())
         524  +
                        })?;
         525  +
                        container
  532    526   
                    });
  533    527   
                }
  534    528   
                Some(18) => {
  535    529   
                    builder.errors = Some({
  536         -
                        let container = if let Some(cap) = deser.container_size() {
  537         -
                            Vec::with_capacity(cap)
  538         -
                        } else {
  539         -
                            Vec::new()
  540         -
                        };
  541         -
                        deser.read_list(member, container, |mut list, deser| {
  542         -
                            list.push(crate::types::DescribeFleetError::deserialize(deser)?);
  543         -
                            Ok(list)
  544         -
                        })?
         530  +
                        let mut container = Vec::new();
         531  +
                        deser.read_list(member, &mut |deser| {
         532  +
                            container.push(crate::types::DescribeFleetError::deserialize(deser)?);
         533  +
                            Ok(())
         534  +
                        })?;
         535  +
                        container
  545    536   
                    });
  546    537   
                }
  547    538   
                Some(19) => {
  548    539   
                    builder.instances = Some({
  549         -
                        let container = if let Some(cap) = deser.container_size() {
  550         -
                            Vec::with_capacity(cap)
  551         -
                        } else {
  552         -
                            Vec::new()
  553         -
                        };
  554         -
                        deser.read_list(member, container, |mut list, deser| {
  555         -
                            list.push(crate::types::DescribeFleetsInstances::deserialize(deser)?);
  556         -
                            Ok(list)
  557         -
                        })?
         540  +
                        let mut container = Vec::new();
         541  +
                        deser.read_list(member, &mut |deser| {
         542  +
                            container.push(crate::types::DescribeFleetsInstances::deserialize(deser)?);
         543  +
                            Ok(())
         544  +
                        })?;
         545  +
                        container
  558    546   
                    });
  559    547   
                }
  560    548   
                Some(20) => {
  561    549   
                    builder.context = Some(deser.read_string(member)?);
  562    550   
                }
  563    551   
                _ => {}
  564    552   
            }
  565    553   
            Ok(())
  566    554   
        })?;
  567    555   
        Ok(builder.build())
  568    556   
    }
  569    557   
}
         558  +
impl FleetData {
         559  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         560  +
    pub fn deserialize_with_response(
         561  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         562  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         563  +
        _status: u16,
         564  +
        _body: &[u8],
         565  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         566  +
        Self::deserialize(deserializer)
         567  +
    }
         568  +
}
  570    569   
impl FleetData {
  571    570   
    /// Creates a new builder-style object to manufacture [`FleetData`](crate::types::FleetData).
  572    571   
    pub fn builder() -> crate::types::builders::FleetDataBuilder {
  573    572   
        crate::types::builders::FleetDataBuilder::default()
  574    573   
    }
  575    574   
}
  576    575   
  577    576   
/// A builder for [`FleetData`](crate::types::FleetData).
  578    577   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  579    578   
#[non_exhaustive]

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

@@ -126,126 +356,367 @@
  146    146   
    "com.amazonaws.ec2",
  147    147   
    "FleetEbsBlockDeviceRequest",
  148    148   
);
  149    149   
static FLEETEBSBLOCKDEVICEREQUEST_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static(
  151    151   
        "com.amazonaws.ec2#FleetEbsBlockDeviceRequest$Encrypted",
  152    152   
        "com.amazonaws.ec2",
  153    153   
        "FleetEbsBlockDeviceRequest",
  154    154   
    ),
  155    155   
    ::aws_smithy_schema::ShapeType::Boolean,
  156         -
    "encrypted",
         156  +
    "Encrypted",
  157    157   
    0,
  158    158   
);
  159    159   
static FLEETEBSBLOCKDEVICEREQUEST_MEMBER_DELETE_ON_TERMINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  160    160   
    ::aws_smithy_schema::ShapeId::from_static(
  161    161   
        "com.amazonaws.ec2#FleetEbsBlockDeviceRequest$DeleteOnTermination",
  162    162   
        "com.amazonaws.ec2",
  163    163   
        "FleetEbsBlockDeviceRequest",
  164    164   
    ),
  165    165   
    ::aws_smithy_schema::ShapeType::Boolean,
  166         -
    "delete_on_termination",
         166  +
    "DeleteOnTermination",
  167    167   
    1,
  168    168   
);
  169    169   
static FLEETEBSBLOCKDEVICEREQUEST_MEMBER_IOPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  170    170   
    ::aws_smithy_schema::ShapeId::from_static(
  171    171   
        "com.amazonaws.ec2#FleetEbsBlockDeviceRequest$Iops",
  172    172   
        "com.amazonaws.ec2",
  173    173   
        "FleetEbsBlockDeviceRequest",
  174    174   
    ),
  175    175   
    ::aws_smithy_schema::ShapeType::Integer,
  176         -
    "iops",
         176  +
    "Iops",
  177    177   
    2,
  178    178   
);
  179    179   
static FLEETEBSBLOCKDEVICEREQUEST_MEMBER_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  180    180   
    ::aws_smithy_schema::ShapeId::from_static(
  181    181   
        "com.amazonaws.ec2#FleetEbsBlockDeviceRequest$Throughput",
  182    182   
        "com.amazonaws.ec2",
  183    183   
        "FleetEbsBlockDeviceRequest",
  184    184   
    ),
  185    185   
    ::aws_smithy_schema::ShapeType::Integer,
  186         -
    "throughput",
         186  +
    "Throughput",
  187    187   
    3,
  188    188   
);
  189    189   
static FLEETEBSBLOCKDEVICEREQUEST_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  190    190   
    ::aws_smithy_schema::ShapeId::from_static(
  191    191   
        "com.amazonaws.ec2#FleetEbsBlockDeviceRequest$KmsKeyId",
  192    192   
        "com.amazonaws.ec2",
  193    193   
        "FleetEbsBlockDeviceRequest",
  194    194   
    ),
  195    195   
    ::aws_smithy_schema::ShapeType::String,
  196         -
    "kms_key_id",
         196  +
    "KmsKeyId",
  197    197   
    4,
  198    198   
);
  199    199   
static FLEETEBSBLOCKDEVICEREQUEST_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  200    200   
    ::aws_smithy_schema::ShapeId::from_static(
  201    201   
        "com.amazonaws.ec2#FleetEbsBlockDeviceRequest$SnapshotId",
  202    202   
        "com.amazonaws.ec2",
  203    203   
        "FleetEbsBlockDeviceRequest",
  204    204   
    ),
  205    205   
    ::aws_smithy_schema::ShapeType::String,
  206         -
    "snapshot_id",
         206  +
    "SnapshotId",
  207    207   
    5,
  208    208   
);
  209    209   
static FLEETEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  210    210   
    ::aws_smithy_schema::ShapeId::from_static(
  211    211   
        "com.amazonaws.ec2#FleetEbsBlockDeviceRequest$VolumeSize",
  212    212   
        "com.amazonaws.ec2",
  213    213   
        "FleetEbsBlockDeviceRequest",
  214    214   
    ),
  215    215   
    ::aws_smithy_schema::ShapeType::Integer,
  216         -
    "volume_size",
         216  +
    "VolumeSize",
  217    217   
    6,
  218    218   
);
  219    219   
static FLEETEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  220    220   
    ::aws_smithy_schema::ShapeId::from_static(
  221    221   
        "com.amazonaws.ec2#FleetEbsBlockDeviceRequest$VolumeType",
  222    222   
        "com.amazonaws.ec2",
  223    223   
        "FleetEbsBlockDeviceRequest",
  224    224   
    ),
  225    225   
    ::aws_smithy_schema::ShapeType::String,
  226         -
    "volume_type",
         226  +
    "VolumeType",
  227    227   
    7,
  228    228   
);
  229    229   
static FLEETEBSBLOCKDEVICEREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  230    230   
    FLEETEBSBLOCKDEVICEREQUEST_SCHEMA_ID,
  231    231   
    ::aws_smithy_schema::ShapeType::Structure,
  232    232   
    &[
  233    233   
        &FLEETEBSBLOCKDEVICEREQUEST_MEMBER_ENCRYPTED,
  234    234   
        &FLEETEBSBLOCKDEVICEREQUEST_MEMBER_DELETE_ON_TERMINATION,
  235    235   
        &FLEETEBSBLOCKDEVICEREQUEST_MEMBER_IOPS,
  236    236   
        &FLEETEBSBLOCKDEVICEREQUEST_MEMBER_THROUGHPUT,
  237    237   
        &FLEETEBSBLOCKDEVICEREQUEST_MEMBER_KMS_KEY_ID,
  238    238   
        &FLEETEBSBLOCKDEVICEREQUEST_MEMBER_SNAPSHOT_ID,
  239    239   
        &FLEETEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_SIZE,
  240    240   
        &FLEETEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_TYPE,
  241    241   
    ],
  242    242   
);
  243    243   
impl FleetEbsBlockDeviceRequest {
  244    244   
    /// The schema for this shape.
  245    245   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLEETEBSBLOCKDEVICEREQUEST_SCHEMA;
  246    246   
}
  247    247   
impl ::aws_smithy_schema::serde::SerializableStruct for FleetEbsBlockDeviceRequest {
  248    248   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  249    249   
    fn serialize_members(
  250    250   
        &self,
  251    251   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  252    252   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  253    253   
        if let Some(ref val) = self.encrypted {
  254    254   
            ser.write_boolean(&FLEETEBSBLOCKDEVICEREQUEST_MEMBER_ENCRYPTED, *val)?;
  255    255   
        }
  256    256   
        if let Some(ref val) = self.delete_on_termination {
  257    257   
            ser.write_boolean(&FLEETEBSBLOCKDEVICEREQUEST_MEMBER_DELETE_ON_TERMINATION, *val)?;
  258    258   
        }
  259    259   
        if let Some(ref val) = self.iops {
  260    260   
            ser.write_integer(&FLEETEBSBLOCKDEVICEREQUEST_MEMBER_IOPS, *val)?;
  261    261   
        }
  262    262   
        if let Some(ref val) = self.throughput {
  263    263   
            ser.write_integer(&FLEETEBSBLOCKDEVICEREQUEST_MEMBER_THROUGHPUT, *val)?;
  264    264   
        }
  265    265   
        if let Some(ref val) = self.kms_key_id {
  266    266   
            ser.write_string(&FLEETEBSBLOCKDEVICEREQUEST_MEMBER_KMS_KEY_ID, val)?;
  267    267   
        }
  268    268   
        if let Some(ref val) = self.snapshot_id {
  269    269   
            ser.write_string(&FLEETEBSBLOCKDEVICEREQUEST_MEMBER_SNAPSHOT_ID, val)?;
  270    270   
        }
  271    271   
        if let Some(ref val) = self.volume_size {
  272    272   
            ser.write_integer(&FLEETEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_SIZE, *val)?;
  273    273   
        }
  274    274   
        if let Some(ref val) = self.volume_type {
  275    275   
            ser.write_string(&FLEETEBSBLOCKDEVICEREQUEST_MEMBER_VOLUME_TYPE, val.as_str())?;
  276    276   
        }
  277    277   
        Ok(())
  278    278   
    }
  279    279   
}
  280    280   
impl FleetEbsBlockDeviceRequest {
  281    281   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  282         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  283         -
        deserializer: &mut D,
         282  +
    pub fn deserialize(
         283  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  284    284   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  285    285   
        #[allow(unused_variables, unused_mut)]
  286    286   
        let mut builder = Self::builder();
  287    287   
        #[allow(
  288    288   
            unused_variables,
  289    289   
            unreachable_code,
  290    290   
            clippy::single_match,
  291    291   
            clippy::match_single_binding,
  292    292   
            clippy::diverging_sub_expression
  293    293   
        )]
  294         -
        deserializer.read_struct(&FLEETEBSBLOCKDEVICEREQUEST_SCHEMA, (), |_, member, deser| {
         294  +
        deserializer.read_struct(&FLEETEBSBLOCKDEVICEREQUEST_SCHEMA, &mut |member, deser| {
  295    295   
            match member.member_index() {
  296    296   
                Some(0) => {
  297    297   
                    builder.encrypted = Some(deser.read_boolean(member)?);
  298    298   
                }
  299    299   
                Some(1) => {
  300    300   
                    builder.delete_on_termination = Some(deser.read_boolean(member)?);
  301    301   
                }
  302    302   
                Some(2) => {
  303    303   
                    builder.iops = Some(deser.read_integer(member)?);
  304    304   
                }
  305    305   
                Some(3) => {
  306    306   
                    builder.throughput = Some(deser.read_integer(member)?);
  307    307   
                }
  308    308   
                Some(4) => {
  309    309   
                    builder.kms_key_id = Some(deser.read_string(member)?);
  310    310   
                }
  311    311   
                Some(5) => {
  312    312   
                    builder.snapshot_id = Some(deser.read_string(member)?);
  313    313   
                }
  314    314   
                Some(6) => {
  315    315   
                    builder.volume_size = Some(deser.read_integer(member)?);
  316    316   
                }
  317    317   
                Some(7) => {
  318    318   
                    builder.volume_type = Some(crate::types::VolumeType::from(deser.read_string(member)?.as_str()));
  319    319   
                }
  320    320   
                _ => {}
  321    321   
            }
  322    322   
            Ok(())
  323    323   
        })?;
  324    324   
        Ok(builder.build())
  325    325   
    }
  326    326   
}
         327  +
impl FleetEbsBlockDeviceRequest {
         328  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         329  +
    pub fn deserialize_with_response(
         330  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         331  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         332  +
        _status: u16,
         333  +
        _body: &[u8],
         334  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         335  +
        Self::deserialize(deserializer)
         336  +
    }
         337  +
}
  327    338   
impl FleetEbsBlockDeviceRequest {
  328    339   
    /// Creates a new builder-style object to manufacture [`FleetEbsBlockDeviceRequest`](crate::types::FleetEbsBlockDeviceRequest).
  329    340   
    pub fn builder() -> crate::types::builders::FleetEbsBlockDeviceRequestBuilder {
  330    341   
        crate::types::builders::FleetEbsBlockDeviceRequestBuilder::default()
  331    342   
    }
  332    343   
}
  333    344   
  334    345   
/// A builder for [`FleetEbsBlockDeviceRequest`](crate::types::FleetEbsBlockDeviceRequest).
  335    346   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  336    347   
#[non_exhaustive]

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

@@ -6,6 +154,162 @@
   26     26   
    "com.amazonaws.ec2",
   27     27   
    "FleetLaunchTemplateConfig",
   28     28   
);
   29     29   
static FLEETLAUNCHTEMPLATECONFIG_MEMBER_LAUNCH_TEMPLATE_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static(
   31     31   
        "com.amazonaws.ec2#FleetLaunchTemplateConfig$LaunchTemplateSpecification",
   32     32   
        "com.amazonaws.ec2",
   33     33   
        "FleetLaunchTemplateConfig",
   34     34   
    ),
   35     35   
    ::aws_smithy_schema::ShapeType::Structure,
   36         -
    "launch_template_specification",
          36  +
    "LaunchTemplateSpecification",
   37     37   
    0,
   38     38   
)
   39     39   
.with_xml_name("launchTemplateSpecification");
   40     40   
static FLEETLAUNCHTEMPLATECONFIG_MEMBER_OVERRIDES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.ec2#FleetLaunchTemplateConfig$Overrides",
   43     43   
        "com.amazonaws.ec2",
   44     44   
        "FleetLaunchTemplateConfig",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::List,
   47         -
    "overrides",
          47  +
    "Overrides",
   48     48   
    1,
   49     49   
)
   50     50   
.with_xml_name("overrides");
   51     51   
static FLEETLAUNCHTEMPLATECONFIG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   52     52   
    FLEETLAUNCHTEMPLATECONFIG_SCHEMA_ID,
   53     53   
    ::aws_smithy_schema::ShapeType::Structure,
   54     54   
    &[
   55     55   
        &FLEETLAUNCHTEMPLATECONFIG_MEMBER_LAUNCH_TEMPLATE_SPECIFICATION,
   56     56   
        &FLEETLAUNCHTEMPLATECONFIG_MEMBER_OVERRIDES,
   57     57   
    ],
   58     58   
);
   59     59   
impl FleetLaunchTemplateConfig {
   60     60   
    /// The schema for this shape.
   61     61   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLEETLAUNCHTEMPLATECONFIG_SCHEMA;
   62     62   
}
   63     63   
impl ::aws_smithy_schema::serde::SerializableStruct for FleetLaunchTemplateConfig {
   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.launch_template_specification {
   70     70   
            ser.write_struct(&FLEETLAUNCHTEMPLATECONFIG_MEMBER_LAUNCH_TEMPLATE_SPECIFICATION, val)?;
   71     71   
        }
   72     72   
        if let Some(ref val) = self.overrides {
   73     73   
            ser.write_list(
   74     74   
                &FLEETLAUNCHTEMPLATECONFIG_MEMBER_OVERRIDES,
   75     75   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   76     76   
                    for item in val {
   77     77   
                        ser.write_struct(crate::types::FleetLaunchTemplateOverrides::SCHEMA, item)?;
   78     78   
                    }
   79     79   
                    Ok(())
   80     80   
                },
   81     81   
            )?;
   82     82   
        }
   83     83   
        Ok(())
   84     84   
    }
   85     85   
}
   86     86   
impl FleetLaunchTemplateConfig {
   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(&FLEETLAUNCHTEMPLATECONFIG_SCHEMA, (), |_, member, deser| {
         100  +
        deserializer.read_struct(&FLEETLAUNCHTEMPLATECONFIG_SCHEMA, &mut |member, deser| {
  101    101   
            match member.member_index() {
  102    102   
                Some(0) => {
  103    103   
                    builder.launch_template_specification = Some(crate::types::FleetLaunchTemplateSpecification::deserialize(deser)?);
  104    104   
                }
  105    105   
                Some(1) => {
  106    106   
                    builder.overrides = 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::FleetLaunchTemplateOverrides::deserialize(deser)?);
  114         -
                            Ok(list)
  115         -
                        })?
         107  +
                        let mut container = Vec::new();
         108  +
                        deser.read_list(member, &mut |deser| {
         109  +
                            container.push(crate::types::FleetLaunchTemplateOverrides::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 FleetLaunchTemplateConfig {
         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 FleetLaunchTemplateConfig {
  126    134   
    /// Creates a new builder-style object to manufacture [`FleetLaunchTemplateConfig`](crate::types::FleetLaunchTemplateConfig).
  127    135   
    pub fn builder() -> crate::types::builders::FleetLaunchTemplateConfigBuilder {
  128    136   
        crate::types::builders::FleetLaunchTemplateConfigBuilder::default()
  129    137   
    }
  130    138   
}
  131    139   
  132    140   
/// A builder for [`FleetLaunchTemplateConfig`](crate::types::FleetLaunchTemplateConfig).
  133    141   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  134    142   
#[non_exhaustive]