AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045

Files changed:

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

@@ -4,4 +134,145 @@
   24     24   
    "com.amazonaws.ec2",
   25     25   
    "CancelledSpotInstanceRequest",
   26     26   
);
   27     27   
static CANCELLEDSPOTINSTANCEREQUEST_MEMBER_SPOT_INSTANCE_REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.ec2#CancelledSpotInstanceRequest$SpotInstanceRequestId",
   30     30   
        "com.amazonaws.ec2",
   31     31   
        "CancelledSpotInstanceRequest",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "spot_instance_request_id",
          34  +
    "SpotInstanceRequestId",
   35     35   
    0,
   36     36   
)
   37     37   
.with_xml_name("spotInstanceRequestId");
   38     38   
static CANCELLEDSPOTINSTANCEREQUEST_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.ec2#CancelledSpotInstanceRequest$State",
   41     41   
        "com.amazonaws.ec2",
   42     42   
        "CancelledSpotInstanceRequest",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45         -
    "state",
          45  +
    "State",
   46     46   
    1,
   47     47   
)
   48     48   
.with_xml_name("state");
   49     49   
static CANCELLEDSPOTINSTANCEREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    CANCELLEDSPOTINSTANCEREQUEST_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[
   53     53   
        &CANCELLEDSPOTINSTANCEREQUEST_MEMBER_SPOT_INSTANCE_REQUEST_ID,
   54     54   
        &CANCELLEDSPOTINSTANCEREQUEST_MEMBER_STATE,
   55     55   
    ],
   56     56   
);
   57     57   
impl CancelledSpotInstanceRequest {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CANCELLEDSPOTINSTANCEREQUEST_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for CancelledSpotInstanceRequest {
   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.spot_instance_request_id {
   68     68   
            ser.write_string(&CANCELLEDSPOTINSTANCEREQUEST_MEMBER_SPOT_INSTANCE_REQUEST_ID, val)?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.state {
   71     71   
            ser.write_string(&CANCELLEDSPOTINSTANCEREQUEST_MEMBER_STATE, val.as_str())?;
   72     72   
        }
   73     73   
        Ok(())
   74     74   
    }
   75     75   
}
   76     76   
impl CancelledSpotInstanceRequest {
   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(&CANCELLEDSPOTINSTANCEREQUEST_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&CANCELLEDSPOTINSTANCEREQUEST_SCHEMA, &mut |member, deser| {
   91     91   
            match member.member_index() {
   92     92   
                Some(0) => {
   93     93   
                    builder.spot_instance_request_id = Some(deser.read_string(member)?);
   94     94   
                }
   95     95   
                Some(1) => {
   96     96   
                    builder.state = Some(crate::types::CancelSpotInstanceRequestState::from(deser.read_string(member)?.as_str()));
   97     97   
                }
   98     98   
                _ => {}
   99     99   
            }
  100    100   
            Ok(())
  101    101   
        })?;
  102    102   
        Ok(builder.build())
  103    103   
    }
  104    104   
}
         105  +
impl CancelledSpotInstanceRequest {
         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 CancelledSpotInstanceRequest {
  106    117   
    /// Creates a new builder-style object to manufacture [`CancelledSpotInstanceRequest`](crate::types::CancelledSpotInstanceRequest).
  107    118   
    pub fn builder() -> crate::types::builders::CancelledSpotInstanceRequestBuilder {
  108    119   
        crate::types::builders::CancelledSpotInstanceRequestBuilder::default()
  109    120   
    }
  110    121   
}
  111    122   
  112    123   
/// A builder for [`CancelledSpotInstanceRequest`](crate::types::CancelledSpotInstanceRequest).
  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/_capacity_allocation.rs

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

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

@@ -50,50 +177,177 @@
   70     70   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
   71     71   
    pub fn tags(&self) -> &[crate::types::Tag] {
   72     72   
        self.tags.as_deref().unwrap_or_default()
   73     73   
    }
   74     74   
}
   75     75   
static CAPACITYBLOCK_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   76     76   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityBlock", "com.amazonaws.ec2", "CapacityBlock");
   77     77   
static CAPACITYBLOCK_MEMBER_CAPACITY_BLOCK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityBlock$CapacityBlockId", "com.amazonaws.ec2", "CapacityBlock"),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "capacity_block_id",
          80  +
    "CapacityBlockId",
   81     81   
    0,
   82     82   
)
   83     83   
.with_xml_name("capacityBlockId");
   84     84   
static CAPACITYBLOCK_MEMBER_ULTRASERVER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityBlock$UltraserverType", "com.amazonaws.ec2", "CapacityBlock"),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "ultraserver_type",
          87  +
    "UltraserverType",
   88     88   
    1,
   89     89   
)
   90     90   
.with_xml_name("ultraserverType");
   91     91   
static CAPACITYBLOCK_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityBlock$AvailabilityZone", "com.amazonaws.ec2", "CapacityBlock"),
   93     93   
    ::aws_smithy_schema::ShapeType::String,
   94         -
    "availability_zone",
          94  +
    "AvailabilityZone",
   95     95   
    2,
   96     96   
)
   97     97   
.with_xml_name("availabilityZone");
   98     98   
static CAPACITYBLOCK_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityBlock$AvailabilityZoneId", "com.amazonaws.ec2", "CapacityBlock"),
  100    100   
    ::aws_smithy_schema::ShapeType::String,
  101         -
    "availability_zone_id",
         101  +
    "AvailabilityZoneId",
  102    102   
    3,
  103    103   
)
  104    104   
.with_xml_name("availabilityZoneId");
  105    105   
static CAPACITYBLOCK_MEMBER_CAPACITY_RESERVATION_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static(
  107    107   
        "com.amazonaws.ec2#CapacityBlock$CapacityReservationIds",
  108    108   
        "com.amazonaws.ec2",
  109    109   
        "CapacityBlock",
  110    110   
    ),
  111    111   
    ::aws_smithy_schema::ShapeType::List,
  112         -
    "capacity_reservation_ids",
         112  +
    "CapacityReservationIds",
  113    113   
    4,
  114    114   
)
  115    115   
.with_xml_name("capacityReservationIdSet");
  116    116   
static CAPACITYBLOCK_MEMBER_START_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  117    117   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityBlock$StartDate", "com.amazonaws.ec2", "CapacityBlock"),
  118    118   
    ::aws_smithy_schema::ShapeType::Timestamp,
  119         -
    "start_date",
         119  +
    "StartDate",
  120    120   
    5,
  121    121   
)
  122    122   
.with_xml_name("startDate");
  123    123   
static CAPACITYBLOCK_MEMBER_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityBlock$EndDate", "com.amazonaws.ec2", "CapacityBlock"),
  125    125   
    ::aws_smithy_schema::ShapeType::Timestamp,
  126         -
    "end_date",
         126  +
    "EndDate",
  127    127   
    6,
  128    128   
)
  129    129   
.with_xml_name("endDate");
  130    130   
static CAPACITYBLOCK_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityBlock$CreateDate", "com.amazonaws.ec2", "CapacityBlock"),
  132    132   
    ::aws_smithy_schema::ShapeType::Timestamp,
  133         -
    "create_date",
         133  +
    "CreateDate",
  134    134   
    7,
  135    135   
)
  136    136   
.with_xml_name("createDate");
  137    137   
static CAPACITYBLOCK_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityBlock$State", "com.amazonaws.ec2", "CapacityBlock"),
  139    139   
    ::aws_smithy_schema::ShapeType::String,
  140         -
    "state",
         140  +
    "State",
  141    141   
    8,
  142    142   
)
  143    143   
.with_xml_name("state");
  144    144   
static CAPACITYBLOCK_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityBlock$Tags", "com.amazonaws.ec2", "CapacityBlock"),
  146    146   
    ::aws_smithy_schema::ShapeType::List,
  147         -
    "tags",
         147  +
    "Tags",
  148    148   
    9,
  149    149   
)
  150    150   
.with_xml_name("tagSet");
  151    151   
static CAPACITYBLOCK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  152    152   
    CAPACITYBLOCK_SCHEMA_ID,
  153    153   
    ::aws_smithy_schema::ShapeType::Structure,
  154    154   
    &[
  155    155   
        &CAPACITYBLOCK_MEMBER_CAPACITY_BLOCK_ID,
  156    156   
        &CAPACITYBLOCK_MEMBER_ULTRASERVER_TYPE,
  157    157   
        &CAPACITYBLOCK_MEMBER_AVAILABILITY_ZONE,
@@ -198,198 +328,326 @@
  218    218   
                    }
  219    219   
                    Ok(())
  220    220   
                },
  221    221   
            )?;
  222    222   
        }
  223    223   
        Ok(())
  224    224   
    }
  225    225   
}
  226    226   
impl CapacityBlock {
  227    227   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  228         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  229         -
        deserializer: &mut D,
         228  +
    pub fn deserialize(
         229  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  230    230   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  231    231   
        #[allow(unused_variables, unused_mut)]
  232    232   
        let mut builder = Self::builder();
  233    233   
        #[allow(
  234    234   
            unused_variables,
  235    235   
            unreachable_code,
  236    236   
            clippy::single_match,
  237    237   
            clippy::match_single_binding,
  238    238   
            clippy::diverging_sub_expression
  239    239   
        )]
  240         -
        deserializer.read_struct(&CAPACITYBLOCK_SCHEMA, (), |_, member, deser| {
         240  +
        deserializer.read_struct(&CAPACITYBLOCK_SCHEMA, &mut |member, deser| {
  241    241   
            match member.member_index() {
  242    242   
                Some(0) => {
  243    243   
                    builder.capacity_block_id = Some(deser.read_string(member)?);
  244    244   
                }
  245    245   
                Some(1) => {
  246    246   
                    builder.ultraserver_type = Some(deser.read_string(member)?);
  247    247   
                }
  248    248   
                Some(2) => {
  249    249   
                    builder.availability_zone = Some(deser.read_string(member)?);
  250    250   
                }
  251    251   
                Some(3) => {
  252    252   
                    builder.availability_zone_id = Some(deser.read_string(member)?);
  253    253   
                }
  254    254   
                Some(4) => {
  255         -
                    builder.capacity_reservation_ids = Some({
  256         -
                        let container = if let Some(cap) = deser.container_size() {
  257         -
                            Vec::with_capacity(cap)
  258         -
                        } else {
  259         -
                            Vec::new()
  260         -
                        };
  261         -
                        deser.read_list(member, container, |mut list, deser| {
  262         -
                            list.push(deser.read_string(member)?);
  263         -
                            Ok(list)
  264         -
                        })?
  265         -
                    });
         255  +
                    builder.capacity_reservation_ids = Some(deser.read_string_list(member)?);
  266    256   
                }
  267    257   
                Some(5) => {
  268    258   
                    builder.start_date = Some(deser.read_timestamp(member)?);
  269    259   
                }
  270    260   
                Some(6) => {
  271    261   
                    builder.end_date = Some(deser.read_timestamp(member)?);
  272    262   
                }
  273    263   
                Some(7) => {
  274    264   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  275    265   
                }
  276    266   
                Some(8) => {
  277    267   
                    builder.state = Some(crate::types::CapacityBlockResourceState::from(deser.read_string(member)?.as_str()));
  278    268   
                }
  279    269   
                Some(9) => {
  280    270   
                    builder.tags = Some({
  281         -
                        let container = if let Some(cap) = deser.container_size() {
  282         -
                            Vec::with_capacity(cap)
  283         -
                        } else {
  284         -
                            Vec::new()
  285         -
                        };
  286         -
                        deser.read_list(member, container, |mut list, deser| {
  287         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  288         -
                            Ok(list)
  289         -
                        })?
         271  +
                        let mut container = Vec::new();
         272  +
                        deser.read_list(member, &mut |deser| {
         273  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         274  +
                            Ok(())
         275  +
                        })?;
         276  +
                        container
  290    277   
                    });
  291    278   
                }
  292    279   
                _ => {}
  293    280   
            }
  294    281   
            Ok(())
  295    282   
        })?;
  296    283   
        Ok(builder.build())
  297    284   
    }
  298    285   
}
         286  +
impl CapacityBlock {
         287  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         288  +
    pub fn deserialize_with_response(
         289  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         290  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         291  +
        _status: u16,
         292  +
        _body: &[u8],
         293  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         294  +
        Self::deserialize(deserializer)
         295  +
    }
         296  +
}
  299    297   
impl CapacityBlock {
  300    298   
    /// Creates a new builder-style object to manufacture [`CapacityBlock`](crate::types::CapacityBlock).
  301    299   
    pub fn builder() -> crate::types::builders::CapacityBlockBuilder {
  302    300   
        crate::types::builders::CapacityBlockBuilder::default()
  303    301   
    }
  304    302   
}
  305    303   
  306    304   
/// A builder for [`CapacityBlock`](crate::types::CapacityBlock).
  307    305   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  308    306   
#[non_exhaustive]

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

@@ -83,83 +275,275 @@
  103    103   
}
  104    104   
static CAPACITYBLOCKEXTENSION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  105    105   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityBlockExtension", "com.amazonaws.ec2", "CapacityBlockExtension");
  106    106   
static CAPACITYBLOCKEXTENSION_MEMBER_CAPACITY_RESERVATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.ec2#CapacityBlockExtension$CapacityReservationId",
  109    109   
        "com.amazonaws.ec2",
  110    110   
        "CapacityBlockExtension",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::String,
  113         -
    "capacity_reservation_id",
         113  +
    "CapacityReservationId",
  114    114   
    0,
  115    115   
)
  116    116   
.with_xml_name("capacityReservationId");
  117    117   
static CAPACITYBLOCKEXTENSION_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.ec2#CapacityBlockExtension$InstanceType",
  120    120   
        "com.amazonaws.ec2",
  121    121   
        "CapacityBlockExtension",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::String,
  124         -
    "instance_type",
         124  +
    "InstanceType",
  125    125   
    1,
  126    126   
)
  127    127   
.with_xml_name("instanceType");
  128    128   
static CAPACITYBLOCKEXTENSION_MEMBER_INSTANCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static(
  130    130   
        "com.amazonaws.ec2#CapacityBlockExtension$InstanceCount",
  131    131   
        "com.amazonaws.ec2",
  132    132   
        "CapacityBlockExtension",
  133    133   
    ),
  134    134   
    ::aws_smithy_schema::ShapeType::Integer,
  135         -
    "instance_count",
         135  +
    "InstanceCount",
  136    136   
    2,
  137    137   
)
  138    138   
.with_xml_name("instanceCount");
  139    139   
static CAPACITYBLOCKEXTENSION_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static(
  141    141   
        "com.amazonaws.ec2#CapacityBlockExtension$AvailabilityZone",
  142    142   
        "com.amazonaws.ec2",
  143    143   
        "CapacityBlockExtension",
  144    144   
    ),
  145    145   
    ::aws_smithy_schema::ShapeType::String,
  146         -
    "availability_zone",
         146  +
    "AvailabilityZone",
  147    147   
    3,
  148    148   
)
  149    149   
.with_xml_name("availabilityZone");
  150    150   
static CAPACITYBLOCKEXTENSION_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  151    151   
    ::aws_smithy_schema::ShapeId::from_static(
  152    152   
        "com.amazonaws.ec2#CapacityBlockExtension$AvailabilityZoneId",
  153    153   
        "com.amazonaws.ec2",
  154    154   
        "CapacityBlockExtension",
  155    155   
    ),
  156    156   
    ::aws_smithy_schema::ShapeType::String,
  157         -
    "availability_zone_id",
         157  +
    "AvailabilityZoneId",
  158    158   
    4,
  159    159   
)
  160    160   
.with_xml_name("availabilityZoneId");
  161    161   
static CAPACITYBLOCKEXTENSION_MEMBER_CAPACITY_BLOCK_EXTENSION_OFFERING_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  162    162   
    ::aws_smithy_schema::ShapeId::from_static(
  163    163   
        "com.amazonaws.ec2#CapacityBlockExtension$CapacityBlockExtensionOfferingId",
  164    164   
        "com.amazonaws.ec2",
  165    165   
        "CapacityBlockExtension",
  166    166   
    ),
  167    167   
    ::aws_smithy_schema::ShapeType::String,
  168         -
    "capacity_block_extension_offering_id",
         168  +
    "CapacityBlockExtensionOfferingId",
  169    169   
    5,
  170    170   
)
  171    171   
.with_xml_name("capacityBlockExtensionOfferingId");
  172    172   
static CAPACITYBLOCKEXTENSION_MEMBER_CAPACITY_BLOCK_EXTENSION_DURATION_HOURS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  173    173   
    ::aws_smithy_schema::ShapeId::from_static(
  174    174   
        "com.amazonaws.ec2#CapacityBlockExtension$CapacityBlockExtensionDurationHours",
  175    175   
        "com.amazonaws.ec2",
  176    176   
        "CapacityBlockExtension",
  177    177   
    ),
  178    178   
    ::aws_smithy_schema::ShapeType::Integer,
  179         -
    "capacity_block_extension_duration_hours",
         179  +
    "CapacityBlockExtensionDurationHours",
  180    180   
    6,
  181    181   
)
  182    182   
.with_xml_name("capacityBlockExtensionDurationHours");
  183    183   
static CAPACITYBLOCKEXTENSION_MEMBER_CAPACITY_BLOCK_EXTENSION_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  184    184   
    ::aws_smithy_schema::ShapeId::from_static(
  185    185   
        "com.amazonaws.ec2#CapacityBlockExtension$CapacityBlockExtensionStatus",
  186    186   
        "com.amazonaws.ec2",
  187    187   
        "CapacityBlockExtension",
  188    188   
    ),
  189    189   
    ::aws_smithy_schema::ShapeType::String,
  190         -
    "capacity_block_extension_status",
         190  +
    "CapacityBlockExtensionStatus",
  191    191   
    7,
  192    192   
)
  193    193   
.with_xml_name("capacityBlockExtensionStatus");
  194    194   
static CAPACITYBLOCKEXTENSION_MEMBER_CAPACITY_BLOCK_EXTENSION_PURCHASE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  195    195   
    ::aws_smithy_schema::ShapeId::from_static(
  196    196   
        "com.amazonaws.ec2#CapacityBlockExtension$CapacityBlockExtensionPurchaseDate",
  197    197   
        "com.amazonaws.ec2",
  198    198   
        "CapacityBlockExtension",
  199    199   
    ),
  200    200   
    ::aws_smithy_schema::ShapeType::Timestamp,
  201         -
    "capacity_block_extension_purchase_date",
         201  +
    "CapacityBlockExtensionPurchaseDate",
  202    202   
    8,
  203    203   
)
  204    204   
.with_xml_name("capacityBlockExtensionPurchaseDate");
  205    205   
static CAPACITYBLOCKEXTENSION_MEMBER_CAPACITY_BLOCK_EXTENSION_START_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  206    206   
    ::aws_smithy_schema::ShapeId::from_static(
  207    207   
        "com.amazonaws.ec2#CapacityBlockExtension$CapacityBlockExtensionStartDate",
  208    208   
        "com.amazonaws.ec2",
  209    209   
        "CapacityBlockExtension",
  210    210   
    ),
  211    211   
    ::aws_smithy_schema::ShapeType::Timestamp,
  212         -
    "capacity_block_extension_start_date",
         212  +
    "CapacityBlockExtensionStartDate",
  213    213   
    9,
  214    214   
)
  215    215   
.with_xml_name("capacityBlockExtensionStartDate");
  216    216   
static CAPACITYBLOCKEXTENSION_MEMBER_CAPACITY_BLOCK_EXTENSION_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  217    217   
    ::aws_smithy_schema::ShapeId::from_static(
  218    218   
        "com.amazonaws.ec2#CapacityBlockExtension$CapacityBlockExtensionEndDate",
  219    219   
        "com.amazonaws.ec2",
  220    220   
        "CapacityBlockExtension",
  221    221   
    ),
  222    222   
    ::aws_smithy_schema::ShapeType::Timestamp,
  223         -
    "capacity_block_extension_end_date",
         223  +
    "CapacityBlockExtensionEndDate",
  224    224   
    10,
  225    225   
)
  226    226   
.with_xml_name("capacityBlockExtensionEndDate");
  227    227   
static CAPACITYBLOCKEXTENSION_MEMBER_UPFRONT_FEE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  228    228   
    ::aws_smithy_schema::ShapeId::from_static(
  229    229   
        "com.amazonaws.ec2#CapacityBlockExtension$UpfrontFee",
  230    230   
        "com.amazonaws.ec2",
  231    231   
        "CapacityBlockExtension",
  232    232   
    ),
  233    233   
    ::aws_smithy_schema::ShapeType::String,
  234         -
    "upfront_fee",
         234  +
    "UpfrontFee",
  235    235   
    11,
  236    236   
)
  237    237   
.with_xml_name("upfrontFee");
  238    238   
static CAPACITYBLOCKEXTENSION_MEMBER_CURRENCY_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  239    239   
    ::aws_smithy_schema::ShapeId::from_static(
  240    240   
        "com.amazonaws.ec2#CapacityBlockExtension$CurrencyCode",
  241    241   
        "com.amazonaws.ec2",
  242    242   
        "CapacityBlockExtension",
  243    243   
    ),
  244    244   
    ::aws_smithy_schema::ShapeType::String,
  245         -
    "currency_code",
         245  +
    "CurrencyCode",
  246    246   
    12,
  247    247   
)
  248    248   
.with_xml_name("currencyCode");
  249    249   
static CAPACITYBLOCKEXTENSION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  250    250   
    CAPACITYBLOCKEXTENSION_SCHEMA_ID,
  251    251   
    ::aws_smithy_schema::ShapeType::Structure,
  252    252   
    &[
  253    253   
        &CAPACITYBLOCKEXTENSION_MEMBER_CAPACITY_RESERVATION_ID,
  254    254   
        &CAPACITYBLOCKEXTENSION_MEMBER_INSTANCE_TYPE,
  255    255   
        &CAPACITYBLOCKEXTENSION_MEMBER_INSTANCE_COUNT,
@@ -292,292 +412,423 @@
  312    312   
            ser.write_string(&CAPACITYBLOCKEXTENSION_MEMBER_UPFRONT_FEE, val)?;
  313    313   
        }
  314    314   
        if let Some(ref val) = self.currency_code {
  315    315   
            ser.write_string(&CAPACITYBLOCKEXTENSION_MEMBER_CURRENCY_CODE, val)?;
  316    316   
        }
  317    317   
        Ok(())
  318    318   
    }
  319    319   
}
  320    320   
impl CapacityBlockExtension {
  321    321   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  322         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  323         -
        deserializer: &mut D,
         322  +
    pub fn deserialize(
         323  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  324    324   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  325    325   
        #[allow(unused_variables, unused_mut)]
  326    326   
        let mut builder = Self::builder();
  327    327   
        #[allow(
  328    328   
            unused_variables,
  329    329   
            unreachable_code,
  330    330   
            clippy::single_match,
  331    331   
            clippy::match_single_binding,
  332    332   
            clippy::diverging_sub_expression
  333    333   
        )]
  334         -
        deserializer.read_struct(&CAPACITYBLOCKEXTENSION_SCHEMA, (), |_, member, deser| {
         334  +
        deserializer.read_struct(&CAPACITYBLOCKEXTENSION_SCHEMA, &mut |member, deser| {
  335    335   
            match member.member_index() {
  336    336   
                Some(0) => {
  337    337   
                    builder.capacity_reservation_id = Some(deser.read_string(member)?);
  338    338   
                }
  339    339   
                Some(1) => {
  340    340   
                    builder.instance_type = Some(deser.read_string(member)?);
  341    341   
                }
  342    342   
                Some(2) => {
  343    343   
                    builder.instance_count = Some(deser.read_integer(member)?);
  344    344   
                }
  345    345   
                Some(3) => {
  346    346   
                    builder.availability_zone = Some(deser.read_string(member)?);
  347    347   
                }
  348    348   
                Some(4) => {
  349    349   
                    builder.availability_zone_id = Some(deser.read_string(member)?);
  350    350   
                }
  351    351   
                Some(5) => {
  352    352   
                    builder.capacity_block_extension_offering_id = Some(deser.read_string(member)?);
  353    353   
                }
  354    354   
                Some(6) => {
  355    355   
                    builder.capacity_block_extension_duration_hours = Some(deser.read_integer(member)?);
  356    356   
                }
  357    357   
                Some(7) => {
  358    358   
                    builder.capacity_block_extension_status =
  359    359   
                        Some(crate::types::CapacityBlockExtensionStatus::from(deser.read_string(member)?.as_str()));
  360    360   
                }
  361    361   
                Some(8) => {
  362    362   
                    builder.capacity_block_extension_purchase_date = Some(deser.read_timestamp(member)?);
  363    363   
                }
  364    364   
                Some(9) => {
  365    365   
                    builder.capacity_block_extension_start_date = Some(deser.read_timestamp(member)?);
  366    366   
                }
  367    367   
                Some(10) => {
  368    368   
                    builder.capacity_block_extension_end_date = Some(deser.read_timestamp(member)?);
  369    369   
                }
  370    370   
                Some(11) => {
  371    371   
                    builder.upfront_fee = Some(deser.read_string(member)?);
  372    372   
                }
  373    373   
                Some(12) => {
  374    374   
                    builder.currency_code = Some(deser.read_string(member)?);
  375    375   
                }
  376    376   
                _ => {}
  377    377   
            }
  378    378   
            Ok(())
  379    379   
        })?;
  380    380   
        Ok(builder.build())
  381    381   
    }
  382    382   
}
         383  +
impl CapacityBlockExtension {
         384  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         385  +
    pub fn deserialize_with_response(
         386  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         387  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         388  +
        _status: u16,
         389  +
        _body: &[u8],
         390  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         391  +
        Self::deserialize(deserializer)
         392  +
    }
         393  +
}
  383    394   
impl CapacityBlockExtension {
  384    395   
    /// Creates a new builder-style object to manufacture [`CapacityBlockExtension`](crate::types::CapacityBlockExtension).
  385    396   
    pub fn builder() -> crate::types::builders::CapacityBlockExtensionBuilder {
  386    397   
        crate::types::builders::CapacityBlockExtensionBuilder::default()
  387    398   
    }
  388    399   
}
  389    400   
  390    401   
/// A builder for [`CapacityBlockExtension`](crate::types::CapacityBlockExtension).
  391    402   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  392    403   
#[non_exhaustive]

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

@@ -77,77 +261,261 @@
   97     97   
    "CapacityBlockExtensionOffering",
   98     98   
);
   99     99   
static CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_CAPACITY_BLOCK_EXTENSION_OFFERING_ID: ::aws_smithy_schema::Schema =
  100    100   
    ::aws_smithy_schema::Schema::new_member(
  101    101   
        ::aws_smithy_schema::ShapeId::from_static(
  102    102   
            "com.amazonaws.ec2#CapacityBlockExtensionOffering$CapacityBlockExtensionOfferingId",
  103    103   
            "com.amazonaws.ec2",
  104    104   
            "CapacityBlockExtensionOffering",
  105    105   
        ),
  106    106   
        ::aws_smithy_schema::ShapeType::String,
  107         -
        "capacity_block_extension_offering_id",
         107  +
        "CapacityBlockExtensionOfferingId",
  108    108   
        0,
  109    109   
    )
  110    110   
    .with_xml_name("capacityBlockExtensionOfferingId");
  111    111   
static CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static(
  113    113   
        "com.amazonaws.ec2#CapacityBlockExtensionOffering$InstanceType",
  114    114   
        "com.amazonaws.ec2",
  115    115   
        "CapacityBlockExtensionOffering",
  116    116   
    ),
  117    117   
    ::aws_smithy_schema::ShapeType::String,
  118         -
    "instance_type",
         118  +
    "InstanceType",
  119    119   
    1,
  120    120   
)
  121    121   
.with_xml_name("instanceType");
  122    122   
static CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_INSTANCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  123    123   
    ::aws_smithy_schema::ShapeId::from_static(
  124    124   
        "com.amazonaws.ec2#CapacityBlockExtensionOffering$InstanceCount",
  125    125   
        "com.amazonaws.ec2",
  126    126   
        "CapacityBlockExtensionOffering",
  127    127   
    ),
  128    128   
    ::aws_smithy_schema::ShapeType::Integer,
  129         -
    "instance_count",
         129  +
    "InstanceCount",
  130    130   
    2,
  131    131   
)
  132    132   
.with_xml_name("instanceCount");
  133    133   
static CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  134    134   
    ::aws_smithy_schema::ShapeId::from_static(
  135    135   
        "com.amazonaws.ec2#CapacityBlockExtensionOffering$AvailabilityZone",
  136    136   
        "com.amazonaws.ec2",
  137    137   
        "CapacityBlockExtensionOffering",
  138    138   
    ),
  139    139   
    ::aws_smithy_schema::ShapeType::String,
  140         -
    "availability_zone",
         140  +
    "AvailabilityZone",
  141    141   
    3,
  142    142   
)
  143    143   
.with_xml_name("availabilityZone");
  144    144   
static CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "com.amazonaws.ec2#CapacityBlockExtensionOffering$AvailabilityZoneId",
  147    147   
        "com.amazonaws.ec2",
  148    148   
        "CapacityBlockExtensionOffering",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::String,
  151         -
    "availability_zone_id",
         151  +
    "AvailabilityZoneId",
  152    152   
    4,
  153    153   
)
  154    154   
.with_xml_name("availabilityZoneId");
  155    155   
static CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_START_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  156    156   
    ::aws_smithy_schema::ShapeId::from_static(
  157    157   
        "com.amazonaws.ec2#CapacityBlockExtensionOffering$StartDate",
  158    158   
        "com.amazonaws.ec2",
  159    159   
        "CapacityBlockExtensionOffering",
  160    160   
    ),
  161    161   
    ::aws_smithy_schema::ShapeType::Timestamp,
  162         -
    "start_date",
         162  +
    "StartDate",
  163    163   
    5,
  164    164   
)
  165    165   
.with_xml_name("startDate");
  166    166   
static CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_CAPACITY_BLOCK_EXTENSION_START_DATE: ::aws_smithy_schema::Schema =
  167    167   
    ::aws_smithy_schema::Schema::new_member(
  168    168   
        ::aws_smithy_schema::ShapeId::from_static(
  169    169   
            "com.amazonaws.ec2#CapacityBlockExtensionOffering$CapacityBlockExtensionStartDate",
  170    170   
            "com.amazonaws.ec2",
  171    171   
            "CapacityBlockExtensionOffering",
  172    172   
        ),
  173    173   
        ::aws_smithy_schema::ShapeType::Timestamp,
  174         -
        "capacity_block_extension_start_date",
         174  +
        "CapacityBlockExtensionStartDate",
  175    175   
        6,
  176    176   
    )
  177    177   
    .with_xml_name("capacityBlockExtensionStartDate");
  178    178   
static CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_CAPACITY_BLOCK_EXTENSION_END_DATE: ::aws_smithy_schema::Schema =
  179    179   
    ::aws_smithy_schema::Schema::new_member(
  180    180   
        ::aws_smithy_schema::ShapeId::from_static(
  181    181   
            "com.amazonaws.ec2#CapacityBlockExtensionOffering$CapacityBlockExtensionEndDate",
  182    182   
            "com.amazonaws.ec2",
  183    183   
            "CapacityBlockExtensionOffering",
  184    184   
        ),
  185    185   
        ::aws_smithy_schema::ShapeType::Timestamp,
  186         -
        "capacity_block_extension_end_date",
         186  +
        "CapacityBlockExtensionEndDate",
  187    187   
        7,
  188    188   
    )
  189    189   
    .with_xml_name("capacityBlockExtensionEndDate");
  190    190   
static CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_CAPACITY_BLOCK_EXTENSION_DURATION_HOURS: ::aws_smithy_schema::Schema =
  191    191   
    ::aws_smithy_schema::Schema::new_member(
  192    192   
        ::aws_smithy_schema::ShapeId::from_static(
  193    193   
            "com.amazonaws.ec2#CapacityBlockExtensionOffering$CapacityBlockExtensionDurationHours",
  194    194   
            "com.amazonaws.ec2",
  195    195   
            "CapacityBlockExtensionOffering",
  196    196   
        ),
  197    197   
        ::aws_smithy_schema::ShapeType::Integer,
  198         -
        "capacity_block_extension_duration_hours",
         198  +
        "CapacityBlockExtensionDurationHours",
  199    199   
        8,
  200    200   
    )
  201    201   
    .with_xml_name("capacityBlockExtensionDurationHours");
  202    202   
static CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_UPFRONT_FEE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  203    203   
    ::aws_smithy_schema::ShapeId::from_static(
  204    204   
        "com.amazonaws.ec2#CapacityBlockExtensionOffering$UpfrontFee",
  205    205   
        "com.amazonaws.ec2",
  206    206   
        "CapacityBlockExtensionOffering",
  207    207   
    ),
  208    208   
    ::aws_smithy_schema::ShapeType::String,
  209         -
    "upfront_fee",
         209  +
    "UpfrontFee",
  210    210   
    9,
  211    211   
)
  212    212   
.with_xml_name("upfrontFee");
  213    213   
static CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_CURRENCY_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  214    214   
    ::aws_smithy_schema::ShapeId::from_static(
  215    215   
        "com.amazonaws.ec2#CapacityBlockExtensionOffering$CurrencyCode",
  216    216   
        "com.amazonaws.ec2",
  217    217   
        "CapacityBlockExtensionOffering",
  218    218   
    ),
  219    219   
    ::aws_smithy_schema::ShapeType::String,
  220         -
    "currency_code",
         220  +
    "CurrencyCode",
  221    221   
    10,
  222    222   
)
  223    223   
.with_xml_name("currencyCode");
  224    224   
static CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_TENANCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  225    225   
    ::aws_smithy_schema::ShapeId::from_static(
  226    226   
        "com.amazonaws.ec2#CapacityBlockExtensionOffering$Tenancy",
  227    227   
        "com.amazonaws.ec2",
  228    228   
        "CapacityBlockExtensionOffering",
  229    229   
    ),
  230    230   
    ::aws_smithy_schema::ShapeType::String,
  231         -
    "tenancy",
         231  +
    "Tenancy",
  232    232   
    11,
  233    233   
)
  234    234   
.with_xml_name("tenancy");
  235    235   
static CAPACITYBLOCKEXTENSIONOFFERING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  236    236   
    CAPACITYBLOCKEXTENSIONOFFERING_SCHEMA_ID,
  237    237   
    ::aws_smithy_schema::ShapeType::Structure,
  238    238   
    &[
  239    239   
        &CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_CAPACITY_BLOCK_EXTENSION_OFFERING_ID,
  240    240   
        &CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_INSTANCE_TYPE,
  241    241   
        &CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_INSTANCE_COUNT,
@@ -274,274 +390,401 @@
  294    294   
            ser.write_string(&CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_CURRENCY_CODE, val)?;
  295    295   
        }
  296    296   
        if let Some(ref val) = self.tenancy {
  297    297   
            ser.write_string(&CAPACITYBLOCKEXTENSIONOFFERING_MEMBER_TENANCY, val.as_str())?;
  298    298   
        }
  299    299   
        Ok(())
  300    300   
    }
  301    301   
}
  302    302   
impl CapacityBlockExtensionOffering {
  303    303   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  304         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  305         -
        deserializer: &mut D,
         304  +
    pub fn deserialize(
         305  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  306    306   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  307    307   
        #[allow(unused_variables, unused_mut)]
  308    308   
        let mut builder = Self::builder();
  309    309   
        #[allow(
  310    310   
            unused_variables,
  311    311   
            unreachable_code,
  312    312   
            clippy::single_match,
  313    313   
            clippy::match_single_binding,
  314    314   
            clippy::diverging_sub_expression
  315    315   
        )]
  316         -
        deserializer.read_struct(&CAPACITYBLOCKEXTENSIONOFFERING_SCHEMA, (), |_, member, deser| {
         316  +
        deserializer.read_struct(&CAPACITYBLOCKEXTENSIONOFFERING_SCHEMA, &mut |member, deser| {
  317    317   
            match member.member_index() {
  318    318   
                Some(0) => {
  319    319   
                    builder.capacity_block_extension_offering_id = Some(deser.read_string(member)?);
  320    320   
                }
  321    321   
                Some(1) => {
  322    322   
                    builder.instance_type = Some(deser.read_string(member)?);
  323    323   
                }
  324    324   
                Some(2) => {
  325    325   
                    builder.instance_count = Some(deser.read_integer(member)?);
  326    326   
                }
  327    327   
                Some(3) => {
  328    328   
                    builder.availability_zone = Some(deser.read_string(member)?);
  329    329   
                }
  330    330   
                Some(4) => {
  331    331   
                    builder.availability_zone_id = Some(deser.read_string(member)?);
  332    332   
                }
  333    333   
                Some(5) => {
  334    334   
                    builder.start_date = Some(deser.read_timestamp(member)?);
  335    335   
                }
  336    336   
                Some(6) => {
  337    337   
                    builder.capacity_block_extension_start_date = Some(deser.read_timestamp(member)?);
  338    338   
                }
  339    339   
                Some(7) => {
  340    340   
                    builder.capacity_block_extension_end_date = Some(deser.read_timestamp(member)?);
  341    341   
                }
  342    342   
                Some(8) => {
  343    343   
                    builder.capacity_block_extension_duration_hours = Some(deser.read_integer(member)?);
  344    344   
                }
  345    345   
                Some(9) => {
  346    346   
                    builder.upfront_fee = Some(deser.read_string(member)?);
  347    347   
                }
  348    348   
                Some(10) => {
  349    349   
                    builder.currency_code = Some(deser.read_string(member)?);
  350    350   
                }
  351    351   
                Some(11) => {
  352    352   
                    builder.tenancy = Some(crate::types::CapacityReservationTenancy::from(deser.read_string(member)?.as_str()));
  353    353   
                }
  354    354   
                _ => {}
  355    355   
            }
  356    356   
            Ok(())
  357    357   
        })?;
  358    358   
        Ok(builder.build())
  359    359   
    }
  360    360   
}
         361  +
impl CapacityBlockExtensionOffering {
         362  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         363  +
    pub fn deserialize_with_response(
         364  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         365  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         366  +
        _status: u16,
         367  +
        _body: &[u8],
         368  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         369  +
        Self::deserialize(deserializer)
         370  +
    }
         371  +
}
  361    372   
impl CapacityBlockExtensionOffering {
  362    373   
    /// Creates a new builder-style object to manufacture [`CapacityBlockExtensionOffering`](crate::types::CapacityBlockExtensionOffering).
  363    374   
    pub fn builder() -> crate::types::builders::CapacityBlockExtensionOfferingBuilder {
  364    375   
        crate::types::builders::CapacityBlockExtensionOfferingBuilder::default()
  365    376   
    }
  366    377   
}
  367    378   
  368    379   
/// A builder for [`CapacityBlockExtensionOffering`](crate::types::CapacityBlockExtensionOffering).
  369    380   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  370    381   
#[non_exhaustive]

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

@@ -67,67 +259,259 @@
   87     87   
}
   88     88   
static CAPACITYBLOCKOFFERING_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   89     89   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityBlockOffering", "com.amazonaws.ec2", "CapacityBlockOffering");
   90     90   
static CAPACITYBLOCKOFFERING_MEMBER_CAPACITY_BLOCK_OFFERING_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.ec2#CapacityBlockOffering$CapacityBlockOfferingId",
   93     93   
        "com.amazonaws.ec2",
   94     94   
        "CapacityBlockOffering",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::String,
   97         -
    "capacity_block_offering_id",
          97  +
    "CapacityBlockOfferingId",
   98     98   
    0,
   99     99   
)
  100    100   
.with_xml_name("capacityBlockOfferingId");
  101    101   
static CAPACITYBLOCKOFFERING_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.ec2#CapacityBlockOffering$InstanceType",
  104    104   
        "com.amazonaws.ec2",
  105    105   
        "CapacityBlockOffering",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "instance_type",
         108  +
    "InstanceType",
  109    109   
    1,
  110    110   
)
  111    111   
.with_xml_name("instanceType");
  112    112   
static CAPACITYBLOCKOFFERING_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.ec2#CapacityBlockOffering$AvailabilityZone",
  115    115   
        "com.amazonaws.ec2",
  116    116   
        "CapacityBlockOffering",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::String,
  119         -
    "availability_zone",
         119  +
    "AvailabilityZone",
  120    120   
    2,
  121    121   
)
  122    122   
.with_xml_name("availabilityZone");
  123    123   
static CAPACITYBLOCKOFFERING_MEMBER_INSTANCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.ec2#CapacityBlockOffering$InstanceCount",
  126    126   
        "com.amazonaws.ec2",
  127    127   
        "CapacityBlockOffering",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::Integer,
  130         -
    "instance_count",
         130  +
    "InstanceCount",
  131    131   
    3,
  132    132   
)
  133    133   
.with_xml_name("instanceCount");
  134    134   
static CAPACITYBLOCKOFFERING_MEMBER_START_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "com.amazonaws.ec2#CapacityBlockOffering$StartDate",
  137    137   
        "com.amazonaws.ec2",
  138    138   
        "CapacityBlockOffering",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::Timestamp,
  141         -
    "start_date",
         141  +
    "StartDate",
  142    142   
    4,
  143    143   
)
  144    144   
.with_xml_name("startDate");
  145    145   
static CAPACITYBLOCKOFFERING_MEMBER_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static(
  147    147   
        "com.amazonaws.ec2#CapacityBlockOffering$EndDate",
  148    148   
        "com.amazonaws.ec2",
  149    149   
        "CapacityBlockOffering",
  150    150   
    ),
  151    151   
    ::aws_smithy_schema::ShapeType::Timestamp,
  152         -
    "end_date",
         152  +
    "EndDate",
  153    153   
    5,
  154    154   
)
  155    155   
.with_xml_name("endDate");
  156    156   
static CAPACITYBLOCKOFFERING_MEMBER_CAPACITY_BLOCK_DURATION_HOURS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  157    157   
    ::aws_smithy_schema::ShapeId::from_static(
  158    158   
        "com.amazonaws.ec2#CapacityBlockOffering$CapacityBlockDurationHours",
  159    159   
        "com.amazonaws.ec2",
  160    160   
        "CapacityBlockOffering",
  161    161   
    ),
  162    162   
    ::aws_smithy_schema::ShapeType::Integer,
  163         -
    "capacity_block_duration_hours",
         163  +
    "CapacityBlockDurationHours",
  164    164   
    6,
  165    165   
)
  166    166   
.with_xml_name("capacityBlockDurationHours");
  167    167   
static CAPACITYBLOCKOFFERING_MEMBER_UPFRONT_FEE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  168    168   
    ::aws_smithy_schema::ShapeId::from_static(
  169    169   
        "com.amazonaws.ec2#CapacityBlockOffering$UpfrontFee",
  170    170   
        "com.amazonaws.ec2",
  171    171   
        "CapacityBlockOffering",
  172    172   
    ),
  173    173   
    ::aws_smithy_schema::ShapeType::String,
  174         -
    "upfront_fee",
         174  +
    "UpfrontFee",
  175    175   
    7,
  176    176   
)
  177    177   
.with_xml_name("upfrontFee");
  178    178   
static CAPACITYBLOCKOFFERING_MEMBER_CURRENCY_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static(
  180    180   
        "com.amazonaws.ec2#CapacityBlockOffering$CurrencyCode",
  181    181   
        "com.amazonaws.ec2",
  182    182   
        "CapacityBlockOffering",
  183    183   
    ),
  184    184   
    ::aws_smithy_schema::ShapeType::String,
  185         -
    "currency_code",
         185  +
    "CurrencyCode",
  186    186   
    8,
  187    187   
)
  188    188   
.with_xml_name("currencyCode");
  189    189   
static CAPACITYBLOCKOFFERING_MEMBER_TENANCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  190    190   
    ::aws_smithy_schema::ShapeId::from_static(
  191    191   
        "com.amazonaws.ec2#CapacityBlockOffering$Tenancy",
  192    192   
        "com.amazonaws.ec2",
  193    193   
        "CapacityBlockOffering",
  194    194   
    ),
  195    195   
    ::aws_smithy_schema::ShapeType::String,
  196         -
    "tenancy",
         196  +
    "Tenancy",
  197    197   
    9,
  198    198   
)
  199    199   
.with_xml_name("tenancy");
  200    200   
static CAPACITYBLOCKOFFERING_MEMBER_ULTRASERVER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  201    201   
    ::aws_smithy_schema::ShapeId::from_static(
  202    202   
        "com.amazonaws.ec2#CapacityBlockOffering$UltraserverType",
  203    203   
        "com.amazonaws.ec2",
  204    204   
        "CapacityBlockOffering",
  205    205   
    ),
  206    206   
    ::aws_smithy_schema::ShapeType::String,
  207         -
    "ultraserver_type",
         207  +
    "UltraserverType",
  208    208   
    10,
  209    209   
)
  210    210   
.with_xml_name("ultraserverType");
  211    211   
static CAPACITYBLOCKOFFERING_MEMBER_ULTRASERVER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  212    212   
    ::aws_smithy_schema::ShapeId::from_static(
  213    213   
        "com.amazonaws.ec2#CapacityBlockOffering$UltraserverCount",
  214    214   
        "com.amazonaws.ec2",
  215    215   
        "CapacityBlockOffering",
  216    216   
    ),
  217    217   
    ::aws_smithy_schema::ShapeType::Integer,
  218         -
    "ultraserver_count",
         218  +
    "UltraserverCount",
  219    219   
    11,
  220    220   
)
  221    221   
.with_xml_name("ultraserverCount");
  222    222   
static CAPACITYBLOCKOFFERING_MEMBER_CAPACITY_BLOCK_DURATION_MINUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  223    223   
    ::aws_smithy_schema::ShapeId::from_static(
  224    224   
        "com.amazonaws.ec2#CapacityBlockOffering$CapacityBlockDurationMinutes",
  225    225   
        "com.amazonaws.ec2",
  226    226   
        "CapacityBlockOffering",
  227    227   
    ),
  228    228   
    ::aws_smithy_schema::ShapeType::Integer,
  229         -
    "capacity_block_duration_minutes",
         229  +
    "CapacityBlockDurationMinutes",
  230    230   
    12,
  231    231   
)
  232    232   
.with_xml_name("capacityBlockDurationMinutes");
  233    233   
static CAPACITYBLOCKOFFERING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  234    234   
    CAPACITYBLOCKOFFERING_SCHEMA_ID,
  235    235   
    ::aws_smithy_schema::ShapeType::Structure,
  236    236   
    &[
  237    237   
        &CAPACITYBLOCKOFFERING_MEMBER_CAPACITY_BLOCK_OFFERING_ID,
  238    238   
        &CAPACITYBLOCKOFFERING_MEMBER_INSTANCE_TYPE,
  239    239   
        &CAPACITYBLOCKOFFERING_MEMBER_AVAILABILITY_ZONE,
@@ -276,276 +395,406 @@
  296    296   
            ser.write_integer(&CAPACITYBLOCKOFFERING_MEMBER_ULTRASERVER_COUNT, *val)?;
  297    297   
        }
  298    298   
        if let Some(ref val) = self.capacity_block_duration_minutes {
  299    299   
            ser.write_integer(&CAPACITYBLOCKOFFERING_MEMBER_CAPACITY_BLOCK_DURATION_MINUTES, *val)?;
  300    300   
        }
  301    301   
        Ok(())
  302    302   
    }
  303    303   
}
  304    304   
impl CapacityBlockOffering {
  305    305   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  306         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  307         -
        deserializer: &mut D,
         306  +
    pub fn deserialize(
         307  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  308    308   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  309    309   
        #[allow(unused_variables, unused_mut)]
  310    310   
        let mut builder = Self::builder();
  311    311   
        #[allow(
  312    312   
            unused_variables,
  313    313   
            unreachable_code,
  314    314   
            clippy::single_match,
  315    315   
            clippy::match_single_binding,
  316    316   
            clippy::diverging_sub_expression
  317    317   
        )]
  318         -
        deserializer.read_struct(&CAPACITYBLOCKOFFERING_SCHEMA, (), |_, member, deser| {
         318  +
        deserializer.read_struct(&CAPACITYBLOCKOFFERING_SCHEMA, &mut |member, deser| {
  319    319   
            match member.member_index() {
  320    320   
                Some(0) => {
  321    321   
                    builder.capacity_block_offering_id = Some(deser.read_string(member)?);
  322    322   
                }
  323    323   
                Some(1) => {
  324    324   
                    builder.instance_type = Some(deser.read_string(member)?);
  325    325   
                }
  326    326   
                Some(2) => {
  327    327   
                    builder.availability_zone = Some(deser.read_string(member)?);
  328    328   
                }
  329    329   
                Some(3) => {
  330    330   
                    builder.instance_count = Some(deser.read_integer(member)?);
  331    331   
                }
  332    332   
                Some(4) => {
  333    333   
                    builder.start_date = Some(deser.read_timestamp(member)?);
  334    334   
                }
  335    335   
                Some(5) => {
  336    336   
                    builder.end_date = Some(deser.read_timestamp(member)?);
  337    337   
                }
  338    338   
                Some(6) => {
  339    339   
                    builder.capacity_block_duration_hours = Some(deser.read_integer(member)?);
  340    340   
                }
  341    341   
                Some(7) => {
  342    342   
                    builder.upfront_fee = Some(deser.read_string(member)?);
  343    343   
                }
  344    344   
                Some(8) => {
  345    345   
                    builder.currency_code = Some(deser.read_string(member)?);
  346    346   
                }
  347    347   
                Some(9) => {
  348    348   
                    builder.tenancy = Some(crate::types::CapacityReservationTenancy::from(deser.read_string(member)?.as_str()));
  349    349   
                }
  350    350   
                Some(10) => {
  351    351   
                    builder.ultraserver_type = Some(deser.read_string(member)?);
  352    352   
                }
  353    353   
                Some(11) => {
  354    354   
                    builder.ultraserver_count = Some(deser.read_integer(member)?);
  355    355   
                }
  356    356   
                Some(12) => {
  357    357   
                    builder.capacity_block_duration_minutes = Some(deser.read_integer(member)?);
  358    358   
                }
  359    359   
                _ => {}
  360    360   
            }
  361    361   
            Ok(())
  362    362   
        })?;
  363    363   
        Ok(builder.build())
  364    364   
    }
  365    365   
}
         366  +
impl CapacityBlockOffering {
         367  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         368  +
    pub fn deserialize_with_response(
         369  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         370  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         371  +
        _status: u16,
         372  +
        _body: &[u8],
         373  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         374  +
        Self::deserialize(deserializer)
         375  +
    }
         376  +
}
  366    377   
impl CapacityBlockOffering {
  367    378   
    /// Creates a new builder-style object to manufacture [`CapacityBlockOffering`](crate::types::CapacityBlockOffering).
  368    379   
    pub fn builder() -> crate::types::builders::CapacityBlockOfferingBuilder {
  369    380   
        crate::types::builders::CapacityBlockOfferingBuilder::default()
  370    381   
    }
  371    382   
}
  372    383   
  373    384   
/// A builder for [`CapacityBlockOffering`](crate::types::CapacityBlockOffering).
  374    385   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  375    386   
#[non_exhaustive]

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

@@ -43,43 +263,271 @@
   63     63   
}
   64     64   
static CAPACITYBLOCKSTATUS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   65     65   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityBlockStatus", "com.amazonaws.ec2", "CapacityBlockStatus");
   66     66   
static CAPACITYBLOCKSTATUS_MEMBER_CAPACITY_BLOCK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "com.amazonaws.ec2#CapacityBlockStatus$CapacityBlockId",
   69     69   
        "com.amazonaws.ec2",
   70     70   
        "CapacityBlockStatus",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::String,
   73         -
    "capacity_block_id",
          73  +
    "CapacityBlockId",
   74     74   
    0,
   75     75   
)
   76     76   
.with_xml_name("capacityBlockId");
   77     77   
static CAPACITYBLOCKSTATUS_MEMBER_INTERCONNECT_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.ec2#CapacityBlockStatus$InterconnectStatus",
   80     80   
        "com.amazonaws.ec2",
   81     81   
        "CapacityBlockStatus",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "interconnect_status",
          84  +
    "InterconnectStatus",
   85     85   
    1,
   86     86   
)
   87     87   
.with_xml_name("interconnectStatus");
   88     88   
static CAPACITYBLOCKSTATUS_MEMBER_TOTAL_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.ec2#CapacityBlockStatus$TotalCapacity",
   91     91   
        "com.amazonaws.ec2",
   92     92   
        "CapacityBlockStatus",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::Integer,
   95         -
    "total_capacity",
          95  +
    "TotalCapacity",
   96     96   
    2,
   97     97   
)
   98     98   
.with_xml_name("totalCapacity");
   99     99   
static CAPACITYBLOCKSTATUS_MEMBER_TOTAL_AVAILABLE_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.ec2#CapacityBlockStatus$TotalAvailableCapacity",
  102    102   
        "com.amazonaws.ec2",
  103    103   
        "CapacityBlockStatus",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::Integer,
  106         -
    "total_available_capacity",
         106  +
    "TotalAvailableCapacity",
  107    107   
    3,
  108    108   
)
  109    109   
.with_xml_name("totalAvailableCapacity");
  110    110   
static CAPACITYBLOCKSTATUS_MEMBER_TOTAL_UNAVAILABLE_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static(
  112    112   
        "com.amazonaws.ec2#CapacityBlockStatus$TotalUnavailableCapacity",
  113    113   
        "com.amazonaws.ec2",
  114    114   
        "CapacityBlockStatus",
  115    115   
    ),
  116    116   
    ::aws_smithy_schema::ShapeType::Integer,
  117         -
    "total_unavailable_capacity",
         117  +
    "TotalUnavailableCapacity",
  118    118   
    4,
  119    119   
)
  120    120   
.with_xml_name("totalUnavailableCapacity");
  121    121   
static CAPACITYBLOCKSTATUS_MEMBER_CAPACITY_RESERVATION_STATUSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static(
  123    123   
        "com.amazonaws.ec2#CapacityBlockStatus$CapacityReservationStatuses",
  124    124   
        "com.amazonaws.ec2",
  125    125   
        "CapacityBlockStatus",
  126    126   
    ),
  127    127   
    ::aws_smithy_schema::ShapeType::List,
  128         -
    "capacity_reservation_statuses",
         128  +
    "CapacityReservationStatuses",
  129    129   
    5,
  130    130   
)
  131    131   
.with_xml_name("capacityReservationStatusSet");
  132    132   
static CAPACITYBLOCKSTATUS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  133    133   
    CAPACITYBLOCKSTATUS_SCHEMA_ID,
  134    134   
    ::aws_smithy_schema::ShapeType::Structure,
  135    135   
    &[
  136    136   
        &CAPACITYBLOCKSTATUS_MEMBER_CAPACITY_BLOCK_ID,
  137    137   
        &CAPACITYBLOCKSTATUS_MEMBER_INTERCONNECT_STATUS,
  138    138   
        &CAPACITYBLOCKSTATUS_MEMBER_TOTAL_CAPACITY,
  139    139   
        &CAPACITYBLOCKSTATUS_MEMBER_TOTAL_AVAILABLE_CAPACITY,
  140    140   
        &CAPACITYBLOCKSTATUS_MEMBER_TOTAL_UNAVAILABLE_CAPACITY,
  141    141   
        &CAPACITYBLOCKSTATUS_MEMBER_CAPACITY_RESERVATION_STATUSES,
  142    142   
    ],
  143    143   
);
  144    144   
impl CapacityBlockStatus {
  145    145   
    /// The schema for this shape.
  146    146   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CAPACITYBLOCKSTATUS_SCHEMA;
  147    147   
}
  148    148   
impl ::aws_smithy_schema::serde::SerializableStruct for CapacityBlockStatus {
  149    149   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  150    150   
    fn serialize_members(
  151    151   
        &self,
  152    152   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  153    153   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  154    154   
        if let Some(ref val) = self.capacity_block_id {
  155    155   
            ser.write_string(&CAPACITYBLOCKSTATUS_MEMBER_CAPACITY_BLOCK_ID, val)?;
  156    156   
        }
  157    157   
        if let Some(ref val) = self.interconnect_status {
  158    158   
            ser.write_string(&CAPACITYBLOCKSTATUS_MEMBER_INTERCONNECT_STATUS, val.as_str())?;
  159    159   
        }
  160    160   
        if let Some(ref val) = self.total_capacity {
  161    161   
            ser.write_integer(&CAPACITYBLOCKSTATUS_MEMBER_TOTAL_CAPACITY, *val)?;
  162    162   
        }
  163    163   
        if let Some(ref val) = self.total_available_capacity {
  164    164   
            ser.write_integer(&CAPACITYBLOCKSTATUS_MEMBER_TOTAL_AVAILABLE_CAPACITY, *val)?;
  165    165   
        }
  166    166   
        if let Some(ref val) = self.total_unavailable_capacity {
  167    167   
            ser.write_integer(&CAPACITYBLOCKSTATUS_MEMBER_TOTAL_UNAVAILABLE_CAPACITY, *val)?;
  168    168   
        }
  169    169   
        if let Some(ref val) = self.capacity_reservation_statuses {
  170    170   
            ser.write_list(
  171    171   
                &CAPACITYBLOCKSTATUS_MEMBER_CAPACITY_RESERVATION_STATUSES,
  172    172   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  173    173   
                    for item in val {
  174    174   
                        ser.write_struct(crate::types::CapacityReservationStatus::SCHEMA, item)?;
  175    175   
                    }
  176    176   
                    Ok(())
  177    177   
                },
  178    178   
            )?;
  179    179   
        }
  180    180   
        Ok(())
  181    181   
    }
  182    182   
}
  183    183   
impl CapacityBlockStatus {
  184    184   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  185         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  186         -
        deserializer: &mut D,
         185  +
    pub fn deserialize(
         186  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  187    187   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  188    188   
        #[allow(unused_variables, unused_mut)]
  189    189   
        let mut builder = Self::builder();
  190    190   
        #[allow(
  191    191   
            unused_variables,
  192    192   
            unreachable_code,
  193    193   
            clippy::single_match,
  194    194   
            clippy::match_single_binding,
  195    195   
            clippy::diverging_sub_expression
  196    196   
        )]
  197         -
        deserializer.read_struct(&CAPACITYBLOCKSTATUS_SCHEMA, (), |_, member, deser| {
         197  +
        deserializer.read_struct(&CAPACITYBLOCKSTATUS_SCHEMA, &mut |member, deser| {
  198    198   
            match member.member_index() {
  199    199   
                Some(0) => {
  200    200   
                    builder.capacity_block_id = Some(deser.read_string(member)?);
  201    201   
                }
  202    202   
                Some(1) => {
  203    203   
                    builder.interconnect_status = Some(crate::types::CapacityBlockInterconnectStatus::from(deser.read_string(member)?.as_str()));
  204    204   
                }
  205    205   
                Some(2) => {
  206    206   
                    builder.total_capacity = Some(deser.read_integer(member)?);
  207    207   
                }
  208    208   
                Some(3) => {
  209    209   
                    builder.total_available_capacity = Some(deser.read_integer(member)?);
  210    210   
                }
  211    211   
                Some(4) => {
  212    212   
                    builder.total_unavailable_capacity = Some(deser.read_integer(member)?);
  213    213   
                }
  214    214   
                Some(5) => {
  215    215   
                    builder.capacity_reservation_statuses = Some({
  216         -
                        let container = if let Some(cap) = deser.container_size() {
  217         -
                            Vec::with_capacity(cap)
  218         -
                        } else {
  219         -
                            Vec::new()
  220         -
                        };
  221         -
                        deser.read_list(member, container, |mut list, deser| {
  222         -
                            list.push(crate::types::CapacityReservationStatus::deserialize(deser)?);
  223         -
                            Ok(list)
  224         -
                        })?
         216  +
                        let mut container = Vec::new();
         217  +
                        deser.read_list(member, &mut |deser| {
         218  +
                            container.push(crate::types::CapacityReservationStatus::deserialize(deser)?);
         219  +
                            Ok(())
         220  +
                        })?;
         221  +
                        container
  225    222   
                    });
  226    223   
                }
  227    224   
                _ => {}
  228    225   
            }
  229    226   
            Ok(())
  230    227   
        })?;
  231    228   
        Ok(builder.build())
  232    229   
    }
  233    230   
}
         231  +
impl CapacityBlockStatus {
         232  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         233  +
    pub fn deserialize_with_response(
         234  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         235  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         236  +
        _status: u16,
         237  +
        _body: &[u8],
         238  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         239  +
        Self::deserialize(deserializer)
         240  +
    }
         241  +
}
  234    242   
impl CapacityBlockStatus {
  235    243   
    /// Creates a new builder-style object to manufacture [`CapacityBlockStatus`](crate::types::CapacityBlockStatus).
  236    244   
    pub fn builder() -> crate::types::builders::CapacityBlockStatusBuilder {
  237    245   
        crate::types::builders::CapacityBlockStatusBuilder::default()
  238    246   
    }
  239    247   
}
  240    248   
  241    249   
/// A builder for [`CapacityBlockStatus`](crate::types::CapacityBlockStatus).
  242    250   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  243    251   
#[non_exhaustive]

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

@@ -245,245 +594,594 @@
  265    265   
}
  266    266   
static CAPACITYRESERVATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  267    267   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityReservation", "com.amazonaws.ec2", "CapacityReservation");
  268    268   
static CAPACITYRESERVATION_MEMBER_CAPACITY_RESERVATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  269    269   
    ::aws_smithy_schema::ShapeId::from_static(
  270    270   
        "com.amazonaws.ec2#CapacityReservation$CapacityReservationId",
  271    271   
        "com.amazonaws.ec2",
  272    272   
        "CapacityReservation",
  273    273   
    ),
  274    274   
    ::aws_smithy_schema::ShapeType::String,
  275         -
    "capacity_reservation_id",
         275  +
    "CapacityReservationId",
  276    276   
    0,
  277    277   
)
  278    278   
.with_xml_name("capacityReservationId");
  279    279   
static CAPACITYRESERVATION_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  280    280   
    ::aws_smithy_schema::ShapeId::from_static(
  281    281   
        "com.amazonaws.ec2#CapacityReservation$OwnerId",
  282    282   
        "com.amazonaws.ec2",
  283    283   
        "CapacityReservation",
  284    284   
    ),
  285    285   
    ::aws_smithy_schema::ShapeType::String,
  286         -
    "owner_id",
         286  +
    "OwnerId",
  287    287   
    1,
  288    288   
)
  289    289   
.with_xml_name("ownerId");
  290    290   
static CAPACITYRESERVATION_MEMBER_CAPACITY_RESERVATION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  291    291   
    ::aws_smithy_schema::ShapeId::from_static(
  292    292   
        "com.amazonaws.ec2#CapacityReservation$CapacityReservationArn",
  293    293   
        "com.amazonaws.ec2",
  294    294   
        "CapacityReservation",
  295    295   
    ),
  296    296   
    ::aws_smithy_schema::ShapeType::String,
  297         -
    "capacity_reservation_arn",
         297  +
    "CapacityReservationArn",
  298    298   
    2,
  299    299   
)
  300    300   
.with_xml_name("capacityReservationArn");
  301    301   
static CAPACITYRESERVATION_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  302    302   
    ::aws_smithy_schema::ShapeId::from_static(
  303    303   
        "com.amazonaws.ec2#CapacityReservation$AvailabilityZoneId",
  304    304   
        "com.amazonaws.ec2",
  305    305   
        "CapacityReservation",
  306    306   
    ),
  307    307   
    ::aws_smithy_schema::ShapeType::String,
  308         -
    "availability_zone_id",
         308  +
    "AvailabilityZoneId",
  309    309   
    3,
  310    310   
)
  311    311   
.with_xml_name("availabilityZoneId");
  312    312   
static CAPACITYRESERVATION_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  313    313   
    ::aws_smithy_schema::ShapeId::from_static(
  314    314   
        "com.amazonaws.ec2#CapacityReservation$InstanceType",
  315    315   
        "com.amazonaws.ec2",
  316    316   
        "CapacityReservation",
  317    317   
    ),
  318    318   
    ::aws_smithy_schema::ShapeType::String,
  319         -
    "instance_type",
         319  +
    "InstanceType",
  320    320   
    4,
  321    321   
)
  322    322   
.with_xml_name("instanceType");
  323    323   
static CAPACITYRESERVATION_MEMBER_INSTANCE_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  324    324   
    ::aws_smithy_schema::ShapeId::from_static(
  325    325   
        "com.amazonaws.ec2#CapacityReservation$InstancePlatform",
  326    326   
        "com.amazonaws.ec2",
  327    327   
        "CapacityReservation",
  328    328   
    ),
  329    329   
    ::aws_smithy_schema::ShapeType::String,
  330         -
    "instance_platform",
         330  +
    "InstancePlatform",
  331    331   
    5,
  332    332   
)
  333    333   
.with_xml_name("instancePlatform");
  334    334   
static CAPACITYRESERVATION_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  335    335   
    ::aws_smithy_schema::ShapeId::from_static(
  336    336   
        "com.amazonaws.ec2#CapacityReservation$AvailabilityZone",
  337    337   
        "com.amazonaws.ec2",
  338    338   
        "CapacityReservation",
  339    339   
    ),
  340    340   
    ::aws_smithy_schema::ShapeType::String,
  341         -
    "availability_zone",
         341  +
    "AvailabilityZone",
  342    342   
    6,
  343    343   
)
  344    344   
.with_xml_name("availabilityZone");
  345    345   
static CAPACITYRESERVATION_MEMBER_TENANCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  346    346   
    ::aws_smithy_schema::ShapeId::from_static(
  347    347   
        "com.amazonaws.ec2#CapacityReservation$Tenancy",
  348    348   
        "com.amazonaws.ec2",
  349    349   
        "CapacityReservation",
  350    350   
    ),
  351    351   
    ::aws_smithy_schema::ShapeType::String,
  352         -
    "tenancy",
         352  +
    "Tenancy",
  353    353   
    7,
  354    354   
)
  355    355   
.with_xml_name("tenancy");
  356    356   
static CAPACITYRESERVATION_MEMBER_TOTAL_INSTANCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  357    357   
    ::aws_smithy_schema::ShapeId::from_static(
  358    358   
        "com.amazonaws.ec2#CapacityReservation$TotalInstanceCount",
  359    359   
        "com.amazonaws.ec2",
  360    360   
        "CapacityReservation",
  361    361   
    ),
  362    362   
    ::aws_smithy_schema::ShapeType::Integer,
  363         -
    "total_instance_count",
         363  +
    "TotalInstanceCount",
  364    364   
    8,
  365    365   
)
  366    366   
.with_xml_name("totalInstanceCount");
  367    367   
static CAPACITYRESERVATION_MEMBER_AVAILABLE_INSTANCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  368    368   
    ::aws_smithy_schema::ShapeId::from_static(
  369    369   
        "com.amazonaws.ec2#CapacityReservation$AvailableInstanceCount",
  370    370   
        "com.amazonaws.ec2",
  371    371   
        "CapacityReservation",
  372    372   
    ),
  373    373   
    ::aws_smithy_schema::ShapeType::Integer,
  374         -
    "available_instance_count",
         374  +
    "AvailableInstanceCount",
  375    375   
    9,
  376    376   
)
  377    377   
.with_xml_name("availableInstanceCount");
  378    378   
static CAPACITYRESERVATION_MEMBER_EBS_OPTIMIZED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  379    379   
    ::aws_smithy_schema::ShapeId::from_static(
  380    380   
        "com.amazonaws.ec2#CapacityReservation$EbsOptimized",
  381    381   
        "com.amazonaws.ec2",
  382    382   
        "CapacityReservation",
  383    383   
    ),
  384    384   
    ::aws_smithy_schema::ShapeType::Boolean,
  385         -
    "ebs_optimized",
         385  +
    "EbsOptimized",
  386    386   
    10,
  387    387   
)
  388    388   
.with_xml_name("ebsOptimized");
  389    389   
static CAPACITYRESERVATION_MEMBER_EPHEMERAL_STORAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  390    390   
    ::aws_smithy_schema::ShapeId::from_static(
  391    391   
        "com.amazonaws.ec2#CapacityReservation$EphemeralStorage",
  392    392   
        "com.amazonaws.ec2",
  393    393   
        "CapacityReservation",
  394    394   
    ),
  395    395   
    ::aws_smithy_schema::ShapeType::Boolean,
  396         -
    "ephemeral_storage",
         396  +
    "EphemeralStorage",
  397    397   
    11,
  398    398   
)
  399    399   
.with_xml_name("ephemeralStorage");
  400    400   
static CAPACITYRESERVATION_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  401    401   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityReservation$State", "com.amazonaws.ec2", "CapacityReservation"),
  402    402   
    ::aws_smithy_schema::ShapeType::String,
  403         -
    "state",
         403  +
    "State",
  404    404   
    12,
  405    405   
)
  406    406   
.with_xml_name("state");
  407    407   
static CAPACITYRESERVATION_MEMBER_START_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  408    408   
    ::aws_smithy_schema::ShapeId::from_static(
  409    409   
        "com.amazonaws.ec2#CapacityReservation$StartDate",
  410    410   
        "com.amazonaws.ec2",
  411    411   
        "CapacityReservation",
  412    412   
    ),
  413    413   
    ::aws_smithy_schema::ShapeType::Timestamp,
  414         -
    "start_date",
         414  +
    "StartDate",
  415    415   
    13,
  416    416   
)
  417    417   
.with_xml_name("startDate");
  418    418   
static CAPACITYRESERVATION_MEMBER_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  419    419   
    ::aws_smithy_schema::ShapeId::from_static(
  420    420   
        "com.amazonaws.ec2#CapacityReservation$EndDate",
  421    421   
        "com.amazonaws.ec2",
  422    422   
        "CapacityReservation",
  423    423   
    ),
  424    424   
    ::aws_smithy_schema::ShapeType::Timestamp,
  425         -
    "end_date",
         425  +
    "EndDate",
  426    426   
    14,
  427    427   
)
  428    428   
.with_xml_name("endDate");
  429    429   
static CAPACITYRESERVATION_MEMBER_END_DATE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  430    430   
    ::aws_smithy_schema::ShapeId::from_static(
  431    431   
        "com.amazonaws.ec2#CapacityReservation$EndDateType",
  432    432   
        "com.amazonaws.ec2",
  433    433   
        "CapacityReservation",
  434    434   
    ),
  435    435   
    ::aws_smithy_schema::ShapeType::String,
  436         -
    "end_date_type",
         436  +
    "EndDateType",
  437    437   
    15,
  438    438   
)
  439    439   
.with_xml_name("endDateType");
  440    440   
static CAPACITYRESERVATION_MEMBER_INSTANCE_MATCH_CRITERIA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  441    441   
    ::aws_smithy_schema::ShapeId::from_static(
  442    442   
        "com.amazonaws.ec2#CapacityReservation$InstanceMatchCriteria",
  443    443   
        "com.amazonaws.ec2",
  444    444   
        "CapacityReservation",
  445    445   
    ),
  446    446   
    ::aws_smithy_schema::ShapeType::String,
  447         -
    "instance_match_criteria",
         447  +
    "InstanceMatchCriteria",
  448    448   
    16,
  449    449   
)
  450    450   
.with_xml_name("instanceMatchCriteria");
  451    451   
static CAPACITYRESERVATION_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  452    452   
    ::aws_smithy_schema::ShapeId::from_static(
  453    453   
        "com.amazonaws.ec2#CapacityReservation$CreateDate",
  454    454   
        "com.amazonaws.ec2",
  455    455   
        "CapacityReservation",
  456    456   
    ),
  457    457   
    ::aws_smithy_schema::ShapeType::Timestamp,
  458         -
    "create_date",
         458  +
    "CreateDate",
  459    459   
    17,
  460    460   
)
  461    461   
.with_xml_name("createDate");
  462    462   
static CAPACITYRESERVATION_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  463    463   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CapacityReservation$Tags", "com.amazonaws.ec2", "CapacityReservation"),
  464    464   
    ::aws_smithy_schema::ShapeType::List,
  465         -
    "tags",
         465  +
    "Tags",
  466    466   
    18,
  467    467   
)
  468    468   
.with_xml_name("tagSet");
  469    469   
static CAPACITYRESERVATION_MEMBER_OUTPOST_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  470    470   
    ::aws_smithy_schema::ShapeId::from_static(
  471    471   
        "com.amazonaws.ec2#CapacityReservation$OutpostArn",
  472    472   
        "com.amazonaws.ec2",
  473    473   
        "CapacityReservation",
  474    474   
    ),
  475    475   
    ::aws_smithy_schema::ShapeType::String,
  476         -
    "outpost_arn",
         476  +
    "OutpostArn",
  477    477   
    19,
  478    478   
)
  479    479   
.with_xml_name("outpostArn");
  480    480   
static CAPACITYRESERVATION_MEMBER_CAPACITY_RESERVATION_FLEET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  481    481   
    ::aws_smithy_schema::ShapeId::from_static(
  482    482   
        "com.amazonaws.ec2#CapacityReservation$CapacityReservationFleetId",
  483    483   
        "com.amazonaws.ec2",
  484    484   
        "CapacityReservation",
  485    485   
    ),
  486    486   
    ::aws_smithy_schema::ShapeType::String,
  487         -
    "capacity_reservation_fleet_id",
         487  +
    "CapacityReservationFleetId",
  488    488   
    20,
  489    489   
)
  490    490   
.with_xml_name("capacityReservationFleetId");
  491    491   
static CAPACITYRESERVATION_MEMBER_PLACEMENT_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  492    492   
    ::aws_smithy_schema::ShapeId::from_static(
  493    493   
        "com.amazonaws.ec2#CapacityReservation$PlacementGroupArn",
  494    494   
        "com.amazonaws.ec2",
  495    495   
        "CapacityReservation",
  496    496   
    ),
  497    497   
    ::aws_smithy_schema::ShapeType::String,
  498         -
    "placement_group_arn",
         498  +
    "PlacementGroupArn",
  499    499   
    21,
  500    500   
)
  501    501   
.with_xml_name("placementGroupArn");
  502    502   
static CAPACITYRESERVATION_MEMBER_CAPACITY_ALLOCATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  503    503   
    ::aws_smithy_schema::ShapeId::from_static(
  504    504   
        "com.amazonaws.ec2#CapacityReservation$CapacityAllocations",
  505    505   
        "com.amazonaws.ec2",
  506    506   
        "CapacityReservation",
  507    507   
    ),
  508    508   
    ::aws_smithy_schema::ShapeType::List,
  509         -
    "capacity_allocations",
         509  +
    "CapacityAllocations",
  510    510   
    22,
  511    511   
)
  512    512   
.with_xml_name("capacityAllocationSet");
  513    513   
static CAPACITYRESERVATION_MEMBER_RESERVATION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  514    514   
    ::aws_smithy_schema::ShapeId::from_static(
  515    515   
        "com.amazonaws.ec2#CapacityReservation$ReservationType",
  516    516   
        "com.amazonaws.ec2",
  517    517   
        "CapacityReservation",
  518    518   
    ),
  519    519   
    ::aws_smithy_schema::ShapeType::String,
  520         -
    "reservation_type",
         520  +
    "ReservationType",
  521    521   
    23,
  522    522   
)
  523    523   
.with_xml_name("reservationType");
  524    524   
static CAPACITYRESERVATION_MEMBER_UNUSED_RESERVATION_BILLING_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  525    525   
    ::aws_smithy_schema::ShapeId::from_static(
  526    526   
        "com.amazonaws.ec2#CapacityReservation$UnusedReservationBillingOwnerId",
  527    527   
        "com.amazonaws.ec2",
  528    528   
        "CapacityReservation",
  529    529   
    ),
  530    530   
    ::aws_smithy_schema::ShapeType::String,
  531         -
    "unused_reservation_billing_owner_id",
         531  +
    "UnusedReservationBillingOwnerId",
  532    532   
    24,
  533    533   
)
  534    534   
.with_xml_name("unusedReservationBillingOwnerId");
  535    535   
static CAPACITYRESERVATION_MEMBER_COMMITMENT_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  536    536   
    ::aws_smithy_schema::ShapeId::from_static(
  537    537   
        "com.amazonaws.ec2#CapacityReservation$CommitmentInfo",
  538    538   
        "com.amazonaws.ec2",
  539    539   
        "CapacityReservation",
  540    540   
    ),
  541    541   
    ::aws_smithy_schema::ShapeType::Structure,
  542         -
    "commitment_info",
         542  +
    "CommitmentInfo",
  543    543   
    25,
  544    544   
)
  545    545   
.with_xml_name("commitmentInfo");
  546    546   
static CAPACITYRESERVATION_MEMBER_DELIVERY_PREFERENCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  547    547   
    ::aws_smithy_schema::ShapeId::from_static(
  548    548   
        "com.amazonaws.ec2#CapacityReservation$DeliveryPreference",
  549    549   
        "com.amazonaws.ec2",
  550    550   
        "CapacityReservation",
  551    551   
    ),
  552    552   
    ::aws_smithy_schema::ShapeType::String,
  553         -
    "delivery_preference",
         553  +
    "DeliveryPreference",
  554    554   
    26,
  555    555   
)
  556    556   
.with_xml_name("deliveryPreference");
  557    557   
static CAPACITYRESERVATION_MEMBER_CAPACITY_BLOCK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  558    558   
    ::aws_smithy_schema::ShapeId::from_static(
  559    559   
        "com.amazonaws.ec2#CapacityReservation$CapacityBlockId",
  560    560   
        "com.amazonaws.ec2",
  561    561   
        "CapacityReservation",
  562    562   
    ),
  563    563   
    ::aws_smithy_schema::ShapeType::String,
  564         -
    "capacity_block_id",
         564  +
    "CapacityBlockId",
  565    565   
    27,
  566    566   
)
  567    567   
.with_xml_name("capacityBlockId");
  568    568   
static CAPACITYRESERVATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  569    569   
    CAPACITYRESERVATION_SCHEMA_ID,
  570    570   
    ::aws_smithy_schema::ShapeType::Structure,
  571    571   
    &[
  572    572   
        &CAPACITYRESERVATION_MEMBER_CAPACITY_RESERVATION_ID,
  573    573   
        &CAPACITYRESERVATION_MEMBER_OWNER_ID,
  574    574   
        &CAPACITYRESERVATION_MEMBER_CAPACITY_RESERVATION_ARN,
@@ -687,687 +875,880 @@
  707    707   
            ser.write_string(&CAPACITYRESERVATION_MEMBER_DELIVERY_PREFERENCE, val.as_str())?;
  708    708   
        }
  709    709   
        if let Some(ref val) = self.capacity_block_id {
  710    710   
            ser.write_string(&CAPACITYRESERVATION_MEMBER_CAPACITY_BLOCK_ID, val)?;
  711    711   
        }
  712    712   
        Ok(())
  713    713   
    }
  714    714   
}
  715    715   
impl CapacityReservation {
  716    716   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  717         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  718         -
        deserializer: &mut D,
         717  +
    pub fn deserialize(
         718  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  719    719   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  720    720   
        #[allow(unused_variables, unused_mut)]
  721    721   
        let mut builder = Self::builder();
  722    722   
        #[allow(
  723    723   
            unused_variables,
  724    724   
            unreachable_code,
  725    725   
            clippy::single_match,
  726    726   
            clippy::match_single_binding,
  727    727   
            clippy::diverging_sub_expression
  728    728   
        )]
  729         -
        deserializer.read_struct(&CAPACITYRESERVATION_SCHEMA, (), |_, member, deser| {
         729  +
        deserializer.read_struct(&CAPACITYRESERVATION_SCHEMA, &mut |member, deser| {
  730    730   
            match member.member_index() {
  731    731   
                Some(0) => {
  732    732   
                    builder.capacity_reservation_id = Some(deser.read_string(member)?);
  733    733   
                }
  734    734   
                Some(1) => {
  735    735   
                    builder.owner_id = Some(deser.read_string(member)?);
  736    736   
                }
  737    737   
                Some(2) => {
  738    738   
                    builder.capacity_reservation_arn = Some(deser.read_string(member)?);
  739    739   
                }
  740    740   
                Some(3) => {
  741    741   
                    builder.availability_zone_id = Some(deser.read_string(member)?);
  742    742   
                }
  743    743   
                Some(4) => {
  744    744   
                    builder.instance_type = Some(deser.read_string(member)?);
  745    745   
                }
  746    746   
                Some(5) => {
  747    747   
                    builder.instance_platform = Some(crate::types::CapacityReservationInstancePlatform::from(
  748    748   
                        deser.read_string(member)?.as_str(),
  749    749   
                    ));
  750    750   
                }
  751    751   
                Some(6) => {
  752    752   
                    builder.availability_zone = Some(deser.read_string(member)?);
  753    753   
                }
  754    754   
                Some(7) => {
  755    755   
                    builder.tenancy = Some(crate::types::CapacityReservationTenancy::from(deser.read_string(member)?.as_str()));
  756    756   
                }
  757    757   
                Some(8) => {
  758    758   
                    builder.total_instance_count = Some(deser.read_integer(member)?);
  759    759   
                }
  760    760   
                Some(9) => {
  761    761   
                    builder.available_instance_count = Some(deser.read_integer(member)?);
  762    762   
                }
  763    763   
                Some(10) => {
  764    764   
                    builder.ebs_optimized = Some(deser.read_boolean(member)?);
  765    765   
                }
  766    766   
                Some(11) => {
  767    767   
                    builder.ephemeral_storage = Some(deser.read_boolean(member)?);
  768    768   
                }
  769    769   
                Some(12) => {
  770    770   
                    builder.state = Some(crate::types::CapacityReservationState::from(deser.read_string(member)?.as_str()));
  771    771   
                }
  772    772   
                Some(13) => {
  773    773   
                    builder.start_date = Some(deser.read_timestamp(member)?);
  774    774   
                }
  775    775   
                Some(14) => {
  776    776   
                    builder.end_date = Some(deser.read_timestamp(member)?);
  777    777   
                }
  778    778   
                Some(15) => {
  779    779   
                    builder.end_date_type = Some(crate::types::EndDateType::from(deser.read_string(member)?.as_str()));
  780    780   
                }
  781    781   
                Some(16) => {
  782    782   
                    builder.instance_match_criteria = Some(crate::types::InstanceMatchCriteria::from(deser.read_string(member)?.as_str()));
  783    783   
                }
  784    784   
                Some(17) => {
  785    785   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  786    786   
                }
  787    787   
                Some(18) => {
  788    788   
                    builder.tags = Some({
  789         -
                        let container = if let Some(cap) = deser.container_size() {
  790         -
                            Vec::with_capacity(cap)
  791         -
                        } else {
  792         -
                            Vec::new()
  793         -
                        };
  794         -
                        deser.read_list(member, container, |mut list, deser| {
  795         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  796         -
                            Ok(list)
  797         -
                        })?
         789  +
                        let mut container = Vec::new();
         790  +
                        deser.read_list(member, &mut |deser| {
         791  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         792  +
                            Ok(())
         793  +
                        })?;
         794  +
                        container
  798    795   
                    });
  799    796   
                }
  800    797   
                Some(19) => {
  801    798   
                    builder.outpost_arn = Some(deser.read_string(member)?);
  802    799   
                }
  803    800   
                Some(20) => {
  804    801   
                    builder.capacity_reservation_fleet_id = Some(deser.read_string(member)?);
  805    802   
                }
  806    803   
                Some(21) => {
  807    804   
                    builder.placement_group_arn = Some(deser.read_string(member)?);
  808    805   
                }
  809    806   
                Some(22) => {
  810    807   
                    builder.capacity_allocations = Some({
  811         -
                        let container = if let Some(cap) = deser.container_size() {
  812         -
                            Vec::with_capacity(cap)
  813         -
                        } else {
  814         -
                            Vec::new()
  815         -
                        };
  816         -
                        deser.read_list(member, container, |mut list, deser| {
  817         -
                            list.push(crate::types::CapacityAllocation::deserialize(deser)?);
  818         -
                            Ok(list)
  819         -
                        })?
         808  +
                        let mut container = Vec::new();
         809  +
                        deser.read_list(member, &mut |deser| {
         810  +
                            container.push(crate::types::CapacityAllocation::deserialize(deser)?);
         811  +
                            Ok(())
         812  +
                        })?;
         813  +
                        container
  820    814   
                    });
  821    815   
                }
  822    816   
                Some(23) => {
  823    817   
                    builder.reservation_type = Some(crate::types::CapacityReservationType::from(deser.read_string(member)?.as_str()));
  824    818   
                }
  825    819   
                Some(24) => {
  826    820   
                    builder.unused_reservation_billing_owner_id = Some(deser.read_string(member)?);
  827    821   
                }
  828    822   
                Some(25) => {
  829    823   
                    builder.commitment_info = Some(crate::types::CapacityReservationCommitmentInfo::deserialize(deser)?);
  830    824   
                }
  831    825   
                Some(26) => {
  832    826   
                    builder.delivery_preference = Some(crate::types::CapacityReservationDeliveryPreference::from(
  833    827   
                        deser.read_string(member)?.as_str(),
  834    828   
                    ));
  835    829   
                }
  836    830   
                Some(27) => {
  837    831   
                    builder.capacity_block_id = Some(deser.read_string(member)?);
  838    832   
                }
  839    833   
                _ => {}
  840    834   
            }
  841    835   
            Ok(())
  842    836   
        })?;
  843    837   
        Ok(builder.build())
  844    838   
    }
  845    839   
}
         840  +
impl CapacityReservation {
         841  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         842  +
    pub fn deserialize_with_response(
         843  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         844  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         845  +
        _status: u16,
         846  +
        _body: &[u8],
         847  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         848  +
        Self::deserialize(deserializer)
         849  +
    }
         850  +
}
  846    851   
impl CapacityReservation {
  847    852   
    /// Creates a new builder-style object to manufacture [`CapacityReservation`](crate::types::CapacityReservation).
  848    853   
    pub fn builder() -> crate::types::builders::CapacityReservationBuilder {
  849    854   
        crate::types::builders::CapacityReservationBuilder::default()
  850    855   
    }
  851    856   
}
  852    857   
  853    858   
/// A builder for [`CapacityReservation`](crate::types::CapacityReservation).
  854    859   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  855    860   
#[non_exhaustive]

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

@@ -34,34 +257,268 @@
   54     54   
    "com.amazonaws.ec2",
   55     55   
    "CapacityReservationBillingRequest",
   56     56   
);
   57     57   
static CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_CAPACITY_RESERVATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.ec2#CapacityReservationBillingRequest$CapacityReservationId",
   60     60   
        "com.amazonaws.ec2",
   61     61   
        "CapacityReservationBillingRequest",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::String,
   64         -
    "capacity_reservation_id",
          64  +
    "CapacityReservationId",
   65     65   
    0,
   66     66   
)
   67     67   
.with_xml_name("capacityReservationId");
   68     68   
static CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_REQUESTED_BY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.ec2#CapacityReservationBillingRequest$RequestedBy",
   71     71   
        "com.amazonaws.ec2",
   72     72   
        "CapacityReservationBillingRequest",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "requested_by",
          75  +
    "RequestedBy",
   76     76   
    1,
   77     77   
)
   78     78   
.with_xml_name("requestedBy");
   79     79   
static CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_UNUSED_RESERVATION_BILLING_OWNER_ID: ::aws_smithy_schema::Schema =
   80     80   
    ::aws_smithy_schema::Schema::new_member(
   81     81   
        ::aws_smithy_schema::ShapeId::from_static(
   82     82   
            "com.amazonaws.ec2#CapacityReservationBillingRequest$UnusedReservationBillingOwnerId",
   83     83   
            "com.amazonaws.ec2",
   84     84   
            "CapacityReservationBillingRequest",
   85     85   
        ),
   86     86   
        ::aws_smithy_schema::ShapeType::String,
   87         -
        "unused_reservation_billing_owner_id",
          87  +
        "UnusedReservationBillingOwnerId",
   88     88   
        2,
   89     89   
    )
   90     90   
    .with_xml_name("unusedReservationBillingOwnerId");
   91     91   
static CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_LAST_UPDATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.ec2#CapacityReservationBillingRequest$LastUpdateTime",
   94     94   
        "com.amazonaws.ec2",
   95     95   
        "CapacityReservationBillingRequest",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::Timestamp,
   98         -
    "last_update_time",
          98  +
    "LastUpdateTime",
   99     99   
    3,
  100    100   
)
  101    101   
.with_xml_name("lastUpdateTime");
  102    102   
static CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static(
  104    104   
        "com.amazonaws.ec2#CapacityReservationBillingRequest$Status",
  105    105   
        "com.amazonaws.ec2",
  106    106   
        "CapacityReservationBillingRequest",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "status",
         109  +
    "Status",
  110    110   
    4,
  111    111   
)
  112    112   
.with_xml_name("status");
  113    113   
static CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static(
  115    115   
        "com.amazonaws.ec2#CapacityReservationBillingRequest$StatusMessage",
  116    116   
        "com.amazonaws.ec2",
  117    117   
        "CapacityReservationBillingRequest",
  118    118   
    ),
  119    119   
    ::aws_smithy_schema::ShapeType::String,
  120         -
    "status_message",
         120  +
    "StatusMessage",
  121    121   
    5,
  122    122   
)
  123    123   
.with_xml_name("statusMessage");
  124    124   
static CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_CAPACITY_RESERVATION_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static(
  126    126   
        "com.amazonaws.ec2#CapacityReservationBillingRequest$CapacityReservationInfo",
  127    127   
        "com.amazonaws.ec2",
  128    128   
        "CapacityReservationBillingRequest",
  129    129   
    ),
  130    130   
    ::aws_smithy_schema::ShapeType::Structure,
  131         -
    "capacity_reservation_info",
         131  +
    "CapacityReservationInfo",
  132    132   
    6,
  133    133   
)
  134    134   
.with_xml_name("capacityReservationInfo");
  135    135   
static CAPACITYRESERVATIONBILLINGREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  136    136   
    CAPACITYRESERVATIONBILLINGREQUEST_SCHEMA_ID,
  137    137   
    ::aws_smithy_schema::ShapeType::Structure,
  138    138   
    &[
  139    139   
        &CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_CAPACITY_RESERVATION_ID,
  140    140   
        &CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_REQUESTED_BY,
  141    141   
        &CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_UNUSED_RESERVATION_BILLING_OWNER_ID,
  142    142   
        &CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_LAST_UPDATE_TIME,
  143    143   
        &CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_STATUS,
  144    144   
        &CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_STATUS_MESSAGE,
  145    145   
        &CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_CAPACITY_RESERVATION_INFO,
  146    146   
    ],
  147    147   
);
  148    148   
impl CapacityReservationBillingRequest {
  149    149   
    /// The schema for this shape.
  150    150   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CAPACITYRESERVATIONBILLINGREQUEST_SCHEMA;
  151    151   
}
  152    152   
impl ::aws_smithy_schema::serde::SerializableStruct for CapacityReservationBillingRequest {
  153    153   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  154    154   
    fn serialize_members(
  155    155   
        &self,
  156    156   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  157    157   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  158    158   
        if let Some(ref val) = self.capacity_reservation_id {
  159    159   
            ser.write_string(&CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_CAPACITY_RESERVATION_ID, val)?;
  160    160   
        }
  161    161   
        if let Some(ref val) = self.requested_by {
  162    162   
            ser.write_string(&CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_REQUESTED_BY, val)?;
  163    163   
        }
  164    164   
        if let Some(ref val) = self.unused_reservation_billing_owner_id {
  165    165   
            ser.write_string(&CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_UNUSED_RESERVATION_BILLING_OWNER_ID, val)?;
  166    166   
        }
  167    167   
        if let Some(ref val) = self.last_update_time {
  168    168   
            ser.write_timestamp(&CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_LAST_UPDATE_TIME, val)?;
  169    169   
        }
  170    170   
        if let Some(ref val) = self.status {
  171    171   
            ser.write_string(&CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_STATUS, val.as_str())?;
  172    172   
        }
  173    173   
        if let Some(ref val) = self.status_message {
  174    174   
            ser.write_string(&CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_STATUS_MESSAGE, val)?;
  175    175   
        }
  176    176   
        if let Some(ref val) = self.capacity_reservation_info {
  177    177   
            ser.write_struct(&CAPACITYRESERVATIONBILLINGREQUEST_MEMBER_CAPACITY_RESERVATION_INFO, val)?;
  178    178   
        }
  179    179   
        Ok(())
  180    180   
    }
  181    181   
}
  182    182   
impl CapacityReservationBillingRequest {
  183    183   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  184         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  185         -
        deserializer: &mut D,
         184  +
    pub fn deserialize(
         185  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  186    186   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  187    187   
        #[allow(unused_variables, unused_mut)]
  188    188   
        let mut builder = Self::builder();
  189    189   
        #[allow(
  190    190   
            unused_variables,
  191    191   
            unreachable_code,
  192    192   
            clippy::single_match,
  193    193   
            clippy::match_single_binding,
  194    194   
            clippy::diverging_sub_expression
  195    195   
        )]
  196         -
        deserializer.read_struct(&CAPACITYRESERVATIONBILLINGREQUEST_SCHEMA, (), |_, member, deser| {
         196  +
        deserializer.read_struct(&CAPACITYRESERVATIONBILLINGREQUEST_SCHEMA, &mut |member, deser| {
  197    197   
            match member.member_index() {
  198    198   
                Some(0) => {
  199    199   
                    builder.capacity_reservation_id = Some(deser.read_string(member)?);
  200    200   
                }
  201    201   
                Some(1) => {
  202    202   
                    builder.requested_by = Some(deser.read_string(member)?);
  203    203   
                }
  204    204   
                Some(2) => {
  205    205   
                    builder.unused_reservation_billing_owner_id = Some(deser.read_string(member)?);
  206    206   
                }
  207    207   
                Some(3) => {
  208    208   
                    builder.last_update_time = Some(deser.read_timestamp(member)?);
  209    209   
                }
  210    210   
                Some(4) => {
  211    211   
                    builder.status = Some(crate::types::CapacityReservationBillingRequestStatus::from(
  212    212   
                        deser.read_string(member)?.as_str(),
  213    213   
                    ));
  214    214   
                }
  215    215   
                Some(5) => {
  216    216   
                    builder.status_message = Some(deser.read_string(member)?);
  217    217   
                }
  218    218   
                Some(6) => {
  219    219   
                    builder.capacity_reservation_info = Some(crate::types::CapacityReservationInfo::deserialize(deser)?);
  220    220   
                }
  221    221   
                _ => {}
  222    222   
            }
  223    223   
            Ok(())
  224    224   
        })?;
  225    225   
        Ok(builder.build())
  226    226   
    }
  227    227   
}
         228  +
impl CapacityReservationBillingRequest {
         229  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         230  +
    pub fn deserialize_with_response(
         231  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         232  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         233  +
        _status: u16,
         234  +
        _body: &[u8],
         235  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         236  +
        Self::deserialize(deserializer)
         237  +
    }
         238  +
}
  228    239   
impl CapacityReservationBillingRequest {
  229    240   
    /// Creates a new builder-style object to manufacture [`CapacityReservationBillingRequest`](crate::types::CapacityReservationBillingRequest).
  230    241   
    pub fn builder() -> crate::types::builders::CapacityReservationBillingRequestBuilder {
  231    242   
        crate::types::builders::CapacityReservationBillingRequestBuilder::default()
  232    243   
    }
  233    244   
}
  234    245   
  235    246   
/// A builder for [`CapacityReservationBillingRequest`](crate::types::CapacityReservationBillingRequest).
  236    247   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  237    248   
#[non_exhaustive]

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

@@ -4,4 +134,145 @@
   24     24   
    "com.amazonaws.ec2",
   25     25   
    "CapacityReservationCommitmentInfo",
   26     26   
);
   27     27   
static CAPACITYRESERVATIONCOMMITMENTINFO_MEMBER_COMMITTED_INSTANCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.ec2#CapacityReservationCommitmentInfo$CommittedInstanceCount",
   30     30   
        "com.amazonaws.ec2",
   31     31   
        "CapacityReservationCommitmentInfo",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::Integer,
   34         -
    "committed_instance_count",
          34  +
    "CommittedInstanceCount",
   35     35   
    0,
   36     36   
)
   37     37   
.with_xml_name("committedInstanceCount");
   38     38   
static CAPACITYRESERVATIONCOMMITMENTINFO_MEMBER_COMMITMENT_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.ec2#CapacityReservationCommitmentInfo$CommitmentEndDate",
   41     41   
        "com.amazonaws.ec2",
   42     42   
        "CapacityReservationCommitmentInfo",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::Timestamp,
   45         -
    "commitment_end_date",
          45  +
    "CommitmentEndDate",
   46     46   
    1,
   47     47   
)
   48     48   
.with_xml_name("commitmentEndDate");
   49     49   
static CAPACITYRESERVATIONCOMMITMENTINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    CAPACITYRESERVATIONCOMMITMENTINFO_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[
   53     53   
        &CAPACITYRESERVATIONCOMMITMENTINFO_MEMBER_COMMITTED_INSTANCE_COUNT,
   54     54   
        &CAPACITYRESERVATIONCOMMITMENTINFO_MEMBER_COMMITMENT_END_DATE,
   55     55   
    ],
   56     56   
);
   57     57   
impl CapacityReservationCommitmentInfo {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CAPACITYRESERVATIONCOMMITMENTINFO_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for CapacityReservationCommitmentInfo {
   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.committed_instance_count {
   68     68   
            ser.write_integer(&CAPACITYRESERVATIONCOMMITMENTINFO_MEMBER_COMMITTED_INSTANCE_COUNT, *val)?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.commitment_end_date {
   71     71   
            ser.write_timestamp(&CAPACITYRESERVATIONCOMMITMENTINFO_MEMBER_COMMITMENT_END_DATE, val)?;
   72     72   
        }
   73     73   
        Ok(())
   74     74   
    }
   75     75   
}
   76     76   
impl CapacityReservationCommitmentInfo {
   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(&CAPACITYRESERVATIONCOMMITMENTINFO_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&CAPACITYRESERVATIONCOMMITMENTINFO_SCHEMA, &mut |member, deser| {
   91     91   
            match member.member_index() {
   92     92   
                Some(0) => {
   93     93   
                    builder.committed_instance_count = Some(deser.read_integer(member)?);
   94     94   
                }
   95     95   
                Some(1) => {
   96     96   
                    builder.commitment_end_date = Some(deser.read_timestamp(member)?);
   97     97   
                }
   98     98   
                _ => {}
   99     99   
            }
  100    100   
            Ok(())
  101    101   
        })?;
  102    102   
        Ok(builder.build())
  103    103   
    }
  104    104   
}
         105  +
impl CapacityReservationCommitmentInfo {
         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 CapacityReservationCommitmentInfo {
  106    117   
    /// Creates a new builder-style object to manufacture [`CapacityReservationCommitmentInfo`](crate::types::CapacityReservationCommitmentInfo).
  107    118   
    pub fn builder() -> crate::types::builders::CapacityReservationCommitmentInfoBuilder {
  108    119   
        crate::types::builders::CapacityReservationCommitmentInfoBuilder::default()
  109    120   
    }
  110    121   
}
  111    122   
  112    123   
/// A builder for [`CapacityReservationCommitmentInfo`](crate::types::CapacityReservationCommitmentInfo).
  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/_capacity_reservation_fleet.rs

@@ -122,122 +303,303 @@
  142    142   
    "com.amazonaws.ec2",
  143    143   
    "CapacityReservationFleet",
  144    144   
);
  145    145   
static CAPACITYRESERVATIONFLEET_MEMBER_CAPACITY_RESERVATION_FLEET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static(
  147    147   
        "com.amazonaws.ec2#CapacityReservationFleet$CapacityReservationFleetId",
  148    148   
        "com.amazonaws.ec2",
  149    149   
        "CapacityReservationFleet",
  150    150   
    ),
  151    151   
    ::aws_smithy_schema::ShapeType::String,
  152         -
    "capacity_reservation_fleet_id",
         152  +
    "CapacityReservationFleetId",
  153    153   
    0,
  154    154   
)
  155    155   
.with_xml_name("capacityReservationFleetId");
  156    156   
static CAPACITYRESERVATIONFLEET_MEMBER_CAPACITY_RESERVATION_FLEET_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  157    157   
    ::aws_smithy_schema::ShapeId::from_static(
  158    158   
        "com.amazonaws.ec2#CapacityReservationFleet$CapacityReservationFleetArn",
  159    159   
        "com.amazonaws.ec2",
  160    160   
        "CapacityReservationFleet",
  161    161   
    ),
  162    162   
    ::aws_smithy_schema::ShapeType::String,
  163         -
    "capacity_reservation_fleet_arn",
         163  +
    "CapacityReservationFleetArn",
  164    164   
    1,
  165    165   
)
  166    166   
.with_xml_name("capacityReservationFleetArn");
  167    167   
static CAPACITYRESERVATIONFLEET_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  168    168   
    ::aws_smithy_schema::ShapeId::from_static(
  169    169   
        "com.amazonaws.ec2#CapacityReservationFleet$State",
  170    170   
        "com.amazonaws.ec2",
  171    171   
        "CapacityReservationFleet",
  172    172   
    ),
  173    173   
    ::aws_smithy_schema::ShapeType::String,
  174         -
    "state",
         174  +
    "State",
  175    175   
    2,
  176    176   
)
  177    177   
.with_xml_name("state");
  178    178   
static CAPACITYRESERVATIONFLEET_MEMBER_TOTAL_TARGET_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static(
  180    180   
        "com.amazonaws.ec2#CapacityReservationFleet$TotalTargetCapacity",
  181    181   
        "com.amazonaws.ec2",
  182    182   
        "CapacityReservationFleet",
  183    183   
    ),
  184    184   
    ::aws_smithy_schema::ShapeType::Integer,
  185         -
    "total_target_capacity",
         185  +
    "TotalTargetCapacity",
  186    186   
    3,
  187    187   
)
  188    188   
.with_xml_name("totalTargetCapacity");
  189    189   
static CAPACITYRESERVATIONFLEET_MEMBER_TOTAL_FULFILLED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  190    190   
    ::aws_smithy_schema::ShapeId::from_static(
  191    191   
        "com.amazonaws.ec2#CapacityReservationFleet$TotalFulfilledCapacity",
  192    192   
        "com.amazonaws.ec2",
  193    193   
        "CapacityReservationFleet",
  194    194   
    ),
  195    195   
    ::aws_smithy_schema::ShapeType::Double,
  196         -
    "total_fulfilled_capacity",
         196  +
    "TotalFulfilledCapacity",
  197    197   
    4,
  198    198   
)
  199    199   
.with_xml_name("totalFulfilledCapacity");
  200    200   
static CAPACITYRESERVATIONFLEET_MEMBER_TENANCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  201    201   
    ::aws_smithy_schema::ShapeId::from_static(
  202    202   
        "com.amazonaws.ec2#CapacityReservationFleet$Tenancy",
  203    203   
        "com.amazonaws.ec2",
  204    204   
        "CapacityReservationFleet",
  205    205   
    ),
  206    206   
    ::aws_smithy_schema::ShapeType::String,
  207         -
    "tenancy",
         207  +
    "Tenancy",
  208    208   
    5,
  209    209   
)
  210    210   
.with_xml_name("tenancy");
  211    211   
static CAPACITYRESERVATIONFLEET_MEMBER_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  212    212   
    ::aws_smithy_schema::ShapeId::from_static(
  213    213   
        "com.amazonaws.ec2#CapacityReservationFleet$EndDate",
  214    214   
        "com.amazonaws.ec2",
  215    215   
        "CapacityReservationFleet",
  216    216   
    ),
  217    217   
    ::aws_smithy_schema::ShapeType::Timestamp,
  218         -
    "end_date",
         218  +
    "EndDate",
  219    219   
    6,
  220    220   
)
  221    221   
.with_xml_name("endDate");
  222    222   
static CAPACITYRESERVATIONFLEET_MEMBER_CREATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  223    223   
    ::aws_smithy_schema::ShapeId::from_static(
  224    224   
        "com.amazonaws.ec2#CapacityReservationFleet$CreateTime",
  225    225   
        "com.amazonaws.ec2",
  226    226   
        "CapacityReservationFleet",
  227    227   
    ),
  228    228   
    ::aws_smithy_schema::ShapeType::Timestamp,
  229         -
    "create_time",
         229  +
    "CreateTime",
  230    230   
    7,
  231    231   
)
  232    232   
.with_xml_name("createTime");
  233    233   
static CAPACITYRESERVATIONFLEET_MEMBER_INSTANCE_MATCH_CRITERIA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  234    234   
    ::aws_smithy_schema::ShapeId::from_static(
  235    235   
        "com.amazonaws.ec2#CapacityReservationFleet$InstanceMatchCriteria",
  236    236   
        "com.amazonaws.ec2",
  237    237   
        "CapacityReservationFleet",
  238    238   
    ),
  239    239   
    ::aws_smithy_schema::ShapeType::String,
  240         -
    "instance_match_criteria",
         240  +
    "InstanceMatchCriteria",
  241    241   
    8,
  242    242   
)
  243    243   
.with_xml_name("instanceMatchCriteria");
  244    244   
static CAPACITYRESERVATIONFLEET_MEMBER_ALLOCATION_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  245    245   
    ::aws_smithy_schema::ShapeId::from_static(
  246    246   
        "com.amazonaws.ec2#CapacityReservationFleet$AllocationStrategy",
  247    247   
        "com.amazonaws.ec2",
  248    248   
        "CapacityReservationFleet",
  249    249   
    ),
  250    250   
    ::aws_smithy_schema::ShapeType::String,
  251         -
    "allocation_strategy",
         251  +
    "AllocationStrategy",
  252    252   
    9,
  253    253   
)
  254    254   
.with_xml_name("allocationStrategy");
  255    255   
static CAPACITYRESERVATIONFLEET_MEMBER_INSTANCE_TYPE_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  256    256   
    ::aws_smithy_schema::ShapeId::from_static(
  257    257   
        "com.amazonaws.ec2#CapacityReservationFleet$InstanceTypeSpecifications",
  258    258   
        "com.amazonaws.ec2",
  259    259   
        "CapacityReservationFleet",
  260    260   
    ),
  261    261   
    ::aws_smithy_schema::ShapeType::List,
  262         -
    "instance_type_specifications",
         262  +
    "InstanceTypeSpecifications",
  263    263   
    10,
  264    264   
)
  265    265   
.with_xml_name("instanceTypeSpecificationSet");
  266    266   
static CAPACITYRESERVATIONFLEET_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  267    267   
    ::aws_smithy_schema::ShapeId::from_static(
  268    268   
        "com.amazonaws.ec2#CapacityReservationFleet$Tags",
  269    269   
        "com.amazonaws.ec2",
  270    270   
        "CapacityReservationFleet",
  271    271   
    ),
  272    272   
    ::aws_smithy_schema::ShapeType::List,
  273         -
    "tags",
         273  +
    "Tags",
  274    274   
    11,
  275    275   
)
  276    276   
.with_xml_name("tagSet");
  277    277   
static CAPACITYRESERVATIONFLEET_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  278    278   
    CAPACITYRESERVATIONFLEET_SCHEMA_ID,
  279    279   
    ::aws_smithy_schema::ShapeType::Structure,
  280    280   
    &[
  281    281   
        &CAPACITYRESERVATIONFLEET_MEMBER_CAPACITY_RESERVATION_FLEET_ID,
  282    282   
        &CAPACITYRESERVATIONFLEET_MEMBER_CAPACITY_RESERVATION_FLEET_ARN,
  283    283   
        &CAPACITYRESERVATIONFLEET_MEMBER_STATE,
@@ -332,332 +468,473 @@
  352    352   
                    }
  353    353   
                    Ok(())
  354    354   
                },
  355    355   
            )?;
  356    356   
        }
  357    357   
        Ok(())
  358    358   
    }
  359    359   
}
  360    360   
impl CapacityReservationFleet {
  361    361   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  362         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  363         -
        deserializer: &mut D,
         362  +
    pub fn deserialize(
         363  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  364    364   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  365    365   
        #[allow(unused_variables, unused_mut)]
  366    366   
        let mut builder = Self::builder();
  367    367   
        #[allow(
  368    368   
            unused_variables,
  369    369   
            unreachable_code,
  370    370   
            clippy::single_match,
  371    371   
            clippy::match_single_binding,
  372    372   
            clippy::diverging_sub_expression
  373    373   
        )]
  374         -
        deserializer.read_struct(&CAPACITYRESERVATIONFLEET_SCHEMA, (), |_, member, deser| {
         374  +
        deserializer.read_struct(&CAPACITYRESERVATIONFLEET_SCHEMA, &mut |member, deser| {
  375    375   
            match member.member_index() {
  376    376   
                Some(0) => {
  377    377   
                    builder.capacity_reservation_fleet_id = Some(deser.read_string(member)?);
  378    378   
                }
  379    379   
                Some(1) => {
  380    380   
                    builder.capacity_reservation_fleet_arn = Some(deser.read_string(member)?);
  381    381   
                }
  382    382   
                Some(2) => {
  383    383   
                    builder.state = Some(crate::types::CapacityReservationFleetState::from(deser.read_string(member)?.as_str()));
  384    384   
                }
  385    385   
                Some(3) => {
  386    386   
                    builder.total_target_capacity = Some(deser.read_integer(member)?);
  387    387   
                }
  388    388   
                Some(4) => {
  389    389   
                    builder.total_fulfilled_capacity = Some(deser.read_double(member)?);
  390    390   
                }
  391    391   
                Some(5) => {
  392    392   
                    builder.tenancy = Some(crate::types::FleetCapacityReservationTenancy::from(deser.read_string(member)?.as_str()));
  393    393   
                }
  394    394   
                Some(6) => {
  395    395   
                    builder.end_date = Some(deser.read_timestamp(member)?);
  396    396   
                }
  397    397   
                Some(7) => {
  398    398   
                    builder.create_time = Some(deser.read_timestamp(member)?);
  399    399   
                }
  400    400   
                Some(8) => {
  401    401   
                    builder.instance_match_criteria = Some(crate::types::FleetInstanceMatchCriteria::from(deser.read_string(member)?.as_str()));
  402    402   
                }
  403    403   
                Some(9) => {
  404    404   
                    builder.allocation_strategy = Some(deser.read_string(member)?);
  405    405   
                }
  406    406   
                Some(10) => {
  407    407   
                    builder.instance_type_specifications = Some({
  408         -
                        let container = if let Some(cap) = deser.container_size() {
  409         -
                            Vec::with_capacity(cap)
  410         -
                        } else {
  411         -
                            Vec::new()
  412         -
                        };
  413         -
                        deser.read_list(member, container, |mut list, deser| {
  414         -
                            list.push(crate::types::FleetCapacityReservation::deserialize(deser)?);
  415         -
                            Ok(list)
  416         -
                        })?
         408  +
                        let mut container = Vec::new();
         409  +
                        deser.read_list(member, &mut |deser| {
         410  +
                            container.push(crate::types::FleetCapacityReservation::deserialize(deser)?);
         411  +
                            Ok(())
         412  +
                        })?;
         413  +
                        container
  417    414   
                    });
  418    415   
                }
  419    416   
                Some(11) => {
  420    417   
                    builder.tags = Some({
  421         -
                        let container = if let Some(cap) = deser.container_size() {
  422         -
                            Vec::with_capacity(cap)
  423         -
                        } else {
  424         -
                            Vec::new()
  425         -
                        };
  426         -
                        deser.read_list(member, container, |mut list, deser| {
  427         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  428         -
                            Ok(list)
  429         -
                        })?
         418  +
                        let mut container = Vec::new();
         419  +
                        deser.read_list(member, &mut |deser| {
         420  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         421  +
                            Ok(())
         422  +
                        })?;
         423  +
                        container
  430    424   
                    });
  431    425   
                }
  432    426   
                _ => {}
  433    427   
            }
  434    428   
            Ok(())
  435    429   
        })?;
  436    430   
        Ok(builder.build())
  437    431   
    }
  438    432   
}
         433  +
impl CapacityReservationFleet {
         434  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         435  +
    pub fn deserialize_with_response(
         436  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         437  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         438  +
        _status: u16,
         439  +
        _body: &[u8],
         440  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         441  +
        Self::deserialize(deserializer)
         442  +
    }
         443  +
}
  439    444   
impl CapacityReservationFleet {
  440    445   
    /// Creates a new builder-style object to manufacture [`CapacityReservationFleet`](crate::types::CapacityReservationFleet).
  441    446   
    pub fn builder() -> crate::types::builders::CapacityReservationFleetBuilder {
  442    447   
        crate::types::builders::CapacityReservationFleetBuilder::default()
  443    448   
    }
  444    449   
}
  445    450   
  446    451   
/// A builder for [`CapacityReservationFleet`](crate::types::CapacityReservationFleet).
  447    452   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  448    453   
#[non_exhaustive]

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

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

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

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

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

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

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

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

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

@@ -5,5 +116,127 @@
   25     25   
    "com.amazonaws.ec2",
   26     26   
    "CapacityReservationOptionsRequest",
   27     27   
);
   28     28   
static CAPACITYRESERVATIONOPTIONSREQUEST_MEMBER_USAGE_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   29     29   
    ::aws_smithy_schema::ShapeId::from_static(
   30     30   
        "com.amazonaws.ec2#CapacityReservationOptionsRequest$UsageStrategy",
   31     31   
        "com.amazonaws.ec2",
   32     32   
        "CapacityReservationOptionsRequest",
   33     33   
    ),
   34     34   
    ::aws_smithy_schema::ShapeType::String,
   35         -
    "usage_strategy",
          35  +
    "UsageStrategy",
   36     36   
    0,
   37     37   
);
   38     38   
static CAPACITYRESERVATIONOPTIONSREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    CAPACITYRESERVATIONOPTIONSREQUEST_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&CAPACITYRESERVATIONOPTIONSREQUEST_MEMBER_USAGE_STRATEGY],
   42     42   
);
   43     43   
impl CapacityReservationOptionsRequest {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CAPACITYRESERVATIONOPTIONSREQUEST_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for CapacityReservationOptionsRequest {
   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.usage_strategy {
   54     54   
            ser.write_string(&CAPACITYRESERVATIONOPTIONSREQUEST_MEMBER_USAGE_STRATEGY, val.as_str())?;
   55     55   
        }
   56     56   
        Ok(())
   57     57   
    }
   58     58   
}
   59     59   
impl CapacityReservationOptionsRequest {
   60     60   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   61         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   62         -
        deserializer: &mut D,
          61  +
    pub fn deserialize(
          62  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   63     63   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   64     64   
        #[allow(unused_variables, unused_mut)]
   65     65   
        let mut builder = Self::builder();
   66     66   
        #[allow(
   67     67   
            unused_variables,
   68     68   
            unreachable_code,
   69     69   
            clippy::single_match,
   70     70   
            clippy::match_single_binding,
   71     71   
            clippy::diverging_sub_expression
   72     72   
        )]
   73         -
        deserializer.read_struct(&CAPACITYRESERVATIONOPTIONSREQUEST_SCHEMA, (), |_, member, deser| {
          73  +
        deserializer.read_struct(&CAPACITYRESERVATIONOPTIONSREQUEST_SCHEMA, &mut |member, deser| {
   74     74   
            match member.member_index() {
   75     75   
                Some(0) => {
   76     76   
                    builder.usage_strategy = Some(crate::types::FleetCapacityReservationUsageStrategy::from(
   77     77   
                        deser.read_string(member)?.as_str(),
   78     78   
                    ));
   79     79   
                }
   80     80   
                _ => {}
   81     81   
            }
   82     82   
            Ok(())
   83     83   
        })?;
   84     84   
        Ok(builder.build())
   85     85   
    }
   86     86   
}
          87  +
impl CapacityReservationOptionsRequest {
          88  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          89  +
    pub fn deserialize_with_response(
          90  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          91  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          92  +
        _status: u16,
          93  +
        _body: &[u8],
          94  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          95  +
        Self::deserialize(deserializer)
          96  +
    }
          97  +
}
   87     98   
impl CapacityReservationOptionsRequest {
   88     99   
    /// Creates a new builder-style object to manufacture [`CapacityReservationOptionsRequest`](crate::types::CapacityReservationOptionsRequest).
   89    100   
    pub fn builder() -> crate::types::builders::CapacityReservationOptionsRequestBuilder {
   90    101   
        crate::types::builders::CapacityReservationOptionsRequestBuilder::default()
   91    102   
    }
   92    103   
}
   93    104   
   94    105   
/// A builder for [`CapacityReservationOptionsRequest`](crate::types::CapacityReservationOptionsRequest).
   95    106   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   96    107   
#[non_exhaustive]