AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/cancel_import_task/_cancel_import_task_output.rs

@@ -10,10 +141,192 @@
   30     30   
    "com.amazonaws.ec2.synthetic",
   31     31   
    "CancelImportTaskOutput",
   32     32   
);
   33     33   
static CANCELIMPORTTASKOUTPUT_MEMBER_IMPORT_TASK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.ec2.synthetic#CancelImportTaskOutput$ImportTaskId",
   36     36   
        "com.amazonaws.ec2.synthetic",
   37     37   
        "CancelImportTaskOutput",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::String,
   40         -
    "import_task_id",
          40  +
    "ImportTaskId",
   41     41   
    0,
   42     42   
)
   43     43   
.with_xml_name("importTaskId");
   44     44   
static CANCELIMPORTTASKOUTPUT_MEMBER_PREVIOUS_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static(
   46     46   
        "com.amazonaws.ec2.synthetic#CancelImportTaskOutput$PreviousState",
   47     47   
        "com.amazonaws.ec2.synthetic",
   48     48   
        "CancelImportTaskOutput",
   49     49   
    ),
   50     50   
    ::aws_smithy_schema::ShapeType::String,
   51         -
    "previous_state",
          51  +
    "PreviousState",
   52     52   
    1,
   53     53   
)
   54     54   
.with_xml_name("previousState");
   55     55   
static CANCELIMPORTTASKOUTPUT_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.ec2.synthetic#CancelImportTaskOutput$State",
   58     58   
        "com.amazonaws.ec2.synthetic",
   59     59   
        "CancelImportTaskOutput",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::String,
   62         -
    "state",
          62  +
    "State",
   63     63   
    2,
   64     64   
)
   65     65   
.with_xml_name("state");
          66  +
static CANCELIMPORTTASKOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          67  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          68  +
    ::aws_smithy_schema::ShapeType::String,
          69  +
    "request_id",
          70  +
    3,
          71  +
)
          72  +
.with_http_header("x-amzn-requestid");
   66     73   
static CANCELIMPORTTASKOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   67     74   
    CANCELIMPORTTASKOUTPUT_SCHEMA_ID,
   68     75   
    ::aws_smithy_schema::ShapeType::Structure,
   69     76   
    &[
   70     77   
        &CANCELIMPORTTASKOUTPUT_MEMBER_IMPORT_TASK_ID,
   71     78   
        &CANCELIMPORTTASKOUTPUT_MEMBER_PREVIOUS_STATE,
   72     79   
        &CANCELIMPORTTASKOUTPUT_MEMBER_STATE,
          80  +
        &CANCELIMPORTTASKOUTPUT_MEMBER__REQUEST_ID,
   73     81   
    ],
   74     82   
);
   75     83   
impl CancelImportTaskOutput {
   76     84   
    /// The schema for this shape.
   77     85   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CANCELIMPORTTASKOUTPUT_SCHEMA;
   78     86   
}
   79     87   
impl ::aws_smithy_schema::serde::SerializableStruct for CancelImportTaskOutput {
   80     88   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   81     89   
    fn serialize_members(
   82     90   
        &self,
   83     91   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   84     92   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   85     93   
        if let Some(ref val) = self.import_task_id {
   86     94   
            ser.write_string(&CANCELIMPORTTASKOUTPUT_MEMBER_IMPORT_TASK_ID, val)?;
   87     95   
        }
   88     96   
        if let Some(ref val) = self.previous_state {
   89     97   
            ser.write_string(&CANCELIMPORTTASKOUTPUT_MEMBER_PREVIOUS_STATE, val)?;
   90     98   
        }
   91     99   
        if let Some(ref val) = self.state {
   92    100   
            ser.write_string(&CANCELIMPORTTASKOUTPUT_MEMBER_STATE, val)?;
   93    101   
        }
   94    102   
        Ok(())
   95    103   
    }
   96    104   
}
   97    105   
impl CancelImportTaskOutput {
   98    106   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   99         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  100         -
        deserializer: &mut D,
         107  +
    pub fn deserialize(
         108  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         109  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         110  +
        #[allow(unused_variables, unused_mut)]
         111  +
        let mut builder = Self::builder();
         112  +
        #[allow(
         113  +
            unused_variables,
         114  +
            unreachable_code,
         115  +
            clippy::single_match,
         116  +
            clippy::match_single_binding,
         117  +
            clippy::diverging_sub_expression
         118  +
        )]
         119  +
        deserializer.read_struct(&CANCELIMPORTTASKOUTPUT_SCHEMA, &mut |member, deser| {
         120  +
            match member.member_index() {
         121  +
                Some(0) => {
         122  +
                    builder.import_task_id = Some(deser.read_string(member)?);
         123  +
                }
         124  +
                Some(1) => {
         125  +
                    builder.previous_state = Some(deser.read_string(member)?);
         126  +
                }
         127  +
                Some(2) => {
         128  +
                    builder.state = Some(deser.read_string(member)?);
         129  +
                }
         130  +
                Some(3) => {
         131  +
                    builder._request_id = Some(deser.read_string(member)?);
         132  +
                }
         133  +
                _ => {}
         134  +
            }
         135  +
            Ok(())
         136  +
        })?;
         137  +
        Ok(builder.build())
         138  +
    }
         139  +
}
         140  +
impl CancelImportTaskOutput {
         141  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         142  +
    /// Header-bound members are read directly from headers, avoiding runtime
         143  +
    /// member iteration overhead. Body members are read via the deserializer.
         144  +
    pub fn deserialize_with_response(
         145  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         146  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         147  +
        _status: u16,
         148  +
        _body: &[u8],
  101    149   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  102    150   
        #[allow(unused_variables, unused_mut)]
  103    151   
        let mut builder = Self::builder();
         152  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         153  +
            builder._request_id = Some(val.to_string());
         154  +
        }
  104    155   
        #[allow(
  105    156   
            unused_variables,
  106    157   
            unreachable_code,
  107    158   
            clippy::single_match,
  108    159   
            clippy::match_single_binding,
  109    160   
            clippy::diverging_sub_expression
  110    161   
        )]
  111         -
        deserializer.read_struct(&CANCELIMPORTTASKOUTPUT_SCHEMA, (), |_, member, deser| {
         162  +
        deserializer.read_struct(&CANCELIMPORTTASKOUTPUT_SCHEMA, &mut |member, deser| {
  112    163   
            match member.member_index() {
  113    164   
                Some(0) => {
  114    165   
                    builder.import_task_id = Some(deser.read_string(member)?);
  115    166   
                }
  116    167   
                Some(1) => {
  117    168   
                    builder.previous_state = Some(deser.read_string(member)?);
  118    169   
                }
  119    170   
                Some(2) => {
  120    171   
                    builder.state = Some(deser.read_string(member)?);
  121    172   
                }

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/cancel_reserved_instances_listing.rs

@@ -1,1 +40,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `CancelReservedInstancesListing`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CancelReservedInstancesListing;
    6      6   
impl CancelReservedInstancesListing {
    7      7   
    /// Creates a new `CancelReservedInstancesListing`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::cancel_reserved_instances_listing::CancelReservedInstancesListingInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::cancel_reserved_instances_listing::CancelReservedInstancesListingOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::cancel_reserved_instances_listing::CancelReservedInstancesListingInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::cancel_reserved_instances_listing::CancelReservedInstancesListingOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::cancel_reserved_instances_listing::CancelReservedInstancesListingError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +186,193 @@
  144    150   
                crate::operation::cancel_reserved_instances_listing::CancelReservedInstancesListingError,
  145    151   
            >::new());
  146    152   
  147    153   
        ::std::borrow::Cow::Owned(rcb)
  148    154   
    }
  149    155   
}
  150    156   
  151    157   
#[derive(Debug)]
  152    158   
struct CancelReservedInstancesListingResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CancelReservedInstancesListingResponseDeserializer {
  154         -
    fn deserialize_nonstreaming(
         160  +
    fn deserialize_nonstreaming_with_config(
  155    161   
        &self,
  156    162   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         163  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  157    164   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  158    165   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  159    166   
        let headers = response.headers();
  160    167   
        let body = response.body().bytes().expect("body loaded");
  161    168   
        #[allow(unused_mut)]
  162    169   
        let mut force_error = false;
  163    170   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  164    171   
        let parse_result = if !success && status != 200 || force_error {
  165    172   
            crate::protocol_serde::shape_cancel_reserved_instances_listing::de_cancel_reserved_instances_listing_http_error(status, headers, body)
  166    173   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/cancel_reserved_instances_listing/_cancel_reserved_instances_listing_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/cancel_reserved_instances_listing/_cancel_reserved_instances_listing_output.rs

@@ -2,2 +121,172 @@
   22     22   
    "CancelReservedInstancesListingOutput",
   23     23   
);
   24     24   
static CANCELRESERVEDINSTANCESLISTINGOUTPUT_MEMBER_RESERVED_INSTANCES_LISTINGS: ::aws_smithy_schema::Schema =
   25     25   
    ::aws_smithy_schema::Schema::new_member(
   26     26   
        ::aws_smithy_schema::ShapeId::from_static(
   27     27   
            "com.amazonaws.ec2.synthetic#CancelReservedInstancesListingOutput$ReservedInstancesListings",
   28     28   
            "com.amazonaws.ec2.synthetic",
   29     29   
            "CancelReservedInstancesListingOutput",
   30     30   
        ),
   31     31   
        ::aws_smithy_schema::ShapeType::List,
   32         -
        "reserved_instances_listings",
          32  +
        "ReservedInstancesListings",
   33     33   
        0,
   34     34   
    )
   35     35   
    .with_xml_name("reservedInstancesListingsSet");
          36  +
static CANCELRESERVEDINSTANCESLISTINGOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          37  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          38  +
    ::aws_smithy_schema::ShapeType::String,
          39  +
    "request_id",
          40  +
    1,
          41  +
)
          42  +
.with_http_header("x-amzn-requestid");
   36     43   
static CANCELRESERVEDINSTANCESLISTINGOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   37     44   
    CANCELRESERVEDINSTANCESLISTINGOUTPUT_SCHEMA_ID,
   38     45   
    ::aws_smithy_schema::ShapeType::Structure,
   39         -
    &[&CANCELRESERVEDINSTANCESLISTINGOUTPUT_MEMBER_RESERVED_INSTANCES_LISTINGS],
          46  +
    &[
          47  +
        &CANCELRESERVEDINSTANCESLISTINGOUTPUT_MEMBER_RESERVED_INSTANCES_LISTINGS,
          48  +
        &CANCELRESERVEDINSTANCESLISTINGOUTPUT_MEMBER__REQUEST_ID,
          49  +
    ],
   40     50   
);
   41     51   
impl CancelReservedInstancesListingOutput {
   42     52   
    /// The schema for this shape.
   43     53   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CANCELRESERVEDINSTANCESLISTINGOUTPUT_SCHEMA;
   44     54   
}
   45     55   
impl ::aws_smithy_schema::serde::SerializableStruct for CancelReservedInstancesListingOutput {
   46     56   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   47     57   
    fn serialize_members(
   48     58   
        &self,
   49     59   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   50     60   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   51     61   
        if let Some(ref val) = self.reserved_instances_listings {
   52     62   
            ser.write_list(
   53     63   
                &CANCELRESERVEDINSTANCESLISTINGOUTPUT_MEMBER_RESERVED_INSTANCES_LISTINGS,
   54     64   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   55     65   
                    for item in val {
   56     66   
                        ser.write_struct(crate::types::ReservedInstancesListing::SCHEMA, item)?;
   57     67   
                    }
   58     68   
                    Ok(())
   59     69   
                },
   60     70   
            )?;
   61     71   
        }
   62     72   
        Ok(())
   63     73   
    }
   64     74   
}
   65     75   
impl CancelReservedInstancesListingOutput {
   66     76   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   67         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   68         -
        deserializer: &mut D,
          77  +
    pub fn deserialize(
          78  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          79  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          80  +
        #[allow(unused_variables, unused_mut)]
          81  +
        let mut builder = Self::builder();
          82  +
        #[allow(
          83  +
            unused_variables,
          84  +
            unreachable_code,
          85  +
            clippy::single_match,
          86  +
            clippy::match_single_binding,
          87  +
            clippy::diverging_sub_expression
          88  +
        )]
          89  +
        deserializer.read_struct(&CANCELRESERVEDINSTANCESLISTINGOUTPUT_SCHEMA, &mut |member, deser| {
          90  +
            match member.member_index() {
          91  +
                Some(0) => {
          92  +
                    builder.reserved_instances_listings = Some({
          93  +
                        let mut container = Vec::new();
          94  +
                        deser.read_list(member, &mut |deser| {
          95  +
                            container.push(crate::types::ReservedInstancesListing::deserialize(deser)?);
          96  +
                            Ok(())
          97  +
                        })?;
          98  +
                        container
          99  +
                    });
         100  +
                }
         101  +
                Some(1) => {
         102  +
                    builder._request_id = Some(deser.read_string(member)?);
         103  +
                }
         104  +
                _ => {}
         105  +
            }
         106  +
            Ok(())
         107  +
        })?;
         108  +
        Ok(builder.build())
         109  +
    }
         110  +
}
         111  +
impl CancelReservedInstancesListingOutput {
         112  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         113  +
    /// Header-bound members are read directly from headers, avoiding runtime
         114  +
    /// member iteration overhead. Body members are read via the deserializer.
         115  +
    pub fn deserialize_with_response(
         116  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         117  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         118  +
        _status: u16,
         119  +
        _body: &[u8],
   69    120   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   70    121   
        #[allow(unused_variables, unused_mut)]
   71    122   
        let mut builder = Self::builder();
         123  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         124  +
            builder._request_id = Some(val.to_string());
         125  +
        }
   72    126   
        #[allow(
   73    127   
            unused_variables,
   74    128   
            unreachable_code,
   75    129   
            clippy::single_match,
   76    130   
            clippy::match_single_binding,
   77    131   
            clippy::diverging_sub_expression
   78    132   
        )]
   79         -
        deserializer.read_struct(&CANCELRESERVEDINSTANCESLISTINGOUTPUT_SCHEMA, (), |_, member, deser| {
         133  +
        deserializer.read_struct(&CANCELRESERVEDINSTANCESLISTINGOUTPUT_SCHEMA, &mut |member, deser| {
   80    134   
            match member.member_index() {
   81    135   
                Some(0) => {
   82    136   
                    builder.reserved_instances_listings = Some({
   83         -
                        let container = if let Some(cap) = deser.container_size() {
   84         -
                            Vec::with_capacity(cap)
   85         -
                        } else {
   86         -
                            Vec::new()
   87         -
                        };
   88         -
                        deser.read_list(member, container, |mut list, deser| {
   89         -
                            list.push(crate::types::ReservedInstancesListing::deserialize(deser)?);
   90         -
                            Ok(list)
   91         -
                        })?
         137  +
                        let mut container = Vec::new();
         138  +
                        deser.read_list(member, &mut |deser| {
         139  +
                            container.push(crate::types::ReservedInstancesListing::deserialize(deser)?);
         140  +
                            Ok(())
         141  +
                        })?;
         142  +
                        container
   92    143   
                    });
   93    144   
                }
   94    145   
                _ => {}
   95    146   
            }
   96    147   
            Ok(())
   97    148   
        })?;
   98    149   
        Ok(builder.build())
   99    150   
    }
  100    151   
}
  101    152   
impl ::aws_types::request_id::RequestId for CancelReservedInstancesListingOutput {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/cancel_spot_fleet_requests.rs

@@ -1,1 +40,45 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `CancelSpotFleetRequests`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CancelSpotFleetRequests;
    6      6   
impl CancelSpotFleetRequests {
    7      7   
    /// Creates a new `CancelSpotFleetRequests`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::cancel_spot_fleet_requests::CancelSpotFleetRequestsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          15  +
        crate::operation::cancel_spot_fleet_requests::CancelSpotFleetRequestsOutput::SCHEMA;
   11     16   
    pub(crate) async fn orchestrate(
   12     17   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     18   
        input: crate::operation::cancel_spot_fleet_requests::CancelSpotFleetRequestsInput,
   14     19   
    ) -> ::std::result::Result<
   15     20   
        crate::operation::cancel_spot_fleet_requests::CancelSpotFleetRequestsOutput,
   16     21   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     22   
            crate::operation::cancel_spot_fleet_requests::CancelSpotFleetRequestsError,
   18     23   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     24   
        >,
   20     25   
    > {
@@ -118,123 +180,186 @@
  138    143   
                crate::operation::cancel_spot_fleet_requests::CancelSpotFleetRequestsError,
  139    144   
            >::new());
  140    145   
  141    146   
        ::std::borrow::Cow::Owned(rcb)
  142    147   
    }
  143    148   
}
  144    149   
  145    150   
#[derive(Debug)]
  146    151   
struct CancelSpotFleetRequestsResponseDeserializer;
  147    152   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CancelSpotFleetRequestsResponseDeserializer {
  148         -
    fn deserialize_nonstreaming(
         153  +
    fn deserialize_nonstreaming_with_config(
  149    154   
        &self,
  150    155   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         156  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    157   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    158   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153    159   
        let headers = response.headers();
  154    160   
        let body = response.body().bytes().expect("body loaded");
  155    161   
        #[allow(unused_mut)]
  156    162   
        let mut force_error = false;
  157    163   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  158    164   
        let parse_result = if !success && status != 200 || force_error {
  159    165   
            crate::protocol_serde::shape_cancel_spot_fleet_requests::de_cancel_spot_fleet_requests_http_error(status, headers, body)
  160    166   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/cancel_spot_fleet_requests/_cancel_spot_fleet_requests_input.rs

@@ -16,16 +184,187 @@
   36     36   
    "com.amazonaws.ec2.synthetic",
   37     37   
    "CancelSpotFleetRequestsInput",
   38     38   
);
   39     39   
static CANCELSPOTFLEETREQUESTSINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.ec2.synthetic#CancelSpotFleetRequestsInput$DryRun",
   42     42   
        "com.amazonaws.ec2.synthetic",
   43     43   
        "CancelSpotFleetRequestsInput",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::Boolean,
   46         -
    "dry_run",
          46  +
    "DryRun",
   47     47   
    0,
   48     48   
)
   49     49   
.with_xml_name("dryRun");
   50     50   
static CANCELSPOTFLEETREQUESTSINPUT_MEMBER_SPOT_FLEET_REQUEST_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.ec2.synthetic#CancelSpotFleetRequestsInput$SpotFleetRequestIds",
   53     53   
        "com.amazonaws.ec2.synthetic",
   54     54   
        "CancelSpotFleetRequestsInput",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::List,
   57         -
    "spot_fleet_request_ids",
          57  +
    "SpotFleetRequestIds",
   58     58   
    1,
   59     59   
)
   60     60   
.with_xml_name("spotFleetRequestId");
   61     61   
static CANCELSPOTFLEETREQUESTSINPUT_MEMBER_TERMINATE_INSTANCES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.ec2.synthetic#CancelSpotFleetRequestsInput$TerminateInstances",
   64     64   
        "com.amazonaws.ec2.synthetic",
   65     65   
        "CancelSpotFleetRequestsInput",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::Boolean,
   68         -
    "terminate_instances",
          68  +
    "TerminateInstances",
   69     69   
    2,
   70     70   
)
   71     71   
.with_xml_name("terminateInstances");
   72     72   
static CANCELSPOTFLEETREQUESTSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   73     73   
    CANCELSPOTFLEETREQUESTSINPUT_SCHEMA_ID,
   74     74   
    ::aws_smithy_schema::ShapeType::Structure,
   75     75   
    &[
   76     76   
        &CANCELSPOTFLEETREQUESTSINPUT_MEMBER_DRY_RUN,
   77     77   
        &CANCELSPOTFLEETREQUESTSINPUT_MEMBER_SPOT_FLEET_REQUEST_IDS,
   78     78   
        &CANCELSPOTFLEETREQUESTSINPUT_MEMBER_TERMINATE_INSTANCES,
   79     79   
    ],
   80     80   
);
   81     81   
impl CancelSpotFleetRequestsInput {
   82     82   
    /// The schema for this shape.
   83     83   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CANCELSPOTFLEETREQUESTSINPUT_SCHEMA;
   84     84   
}
   85     85   
impl ::aws_smithy_schema::serde::SerializableStruct for CancelSpotFleetRequestsInput {
   86     86   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   87     87   
    fn serialize_members(
   88     88   
        &self,
   89     89   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   90     90   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   91     91   
        if let Some(ref val) = self.dry_run {
   92     92   
            ser.write_boolean(&CANCELSPOTFLEETREQUESTSINPUT_MEMBER_DRY_RUN, *val)?;
   93     93   
        }
   94     94   
        if let Some(ref val) = self.spot_fleet_request_ids {
   95     95   
            ser.write_list(
   96     96   
                &CANCELSPOTFLEETREQUESTSINPUT_MEMBER_SPOT_FLEET_REQUEST_IDS,
   97     97   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   98     98   
                    for item in val {
   99     99   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  100    100   
                    }
  101    101   
                    Ok(())
  102    102   
                },
  103    103   
            )?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.terminate_instances {
  106    106   
            ser.write_boolean(&CANCELSPOTFLEETREQUESTSINPUT_MEMBER_TERMINATE_INSTANCES, *val)?;
  107    107   
        }
  108    108   
        Ok(())
  109    109   
    }
  110    110   
}
  111    111   
impl CancelSpotFleetRequestsInput {
  112    112   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  113         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  114         -
        deserializer: &mut D,
         113  +
    pub fn deserialize(
         114  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  115    115   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  116    116   
        #[allow(unused_variables, unused_mut)]
  117    117   
        let mut builder = Self::builder();
  118    118   
        #[allow(
  119    119   
            unused_variables,
  120    120   
            unreachable_code,
  121    121   
            clippy::single_match,
  122    122   
            clippy::match_single_binding,
  123    123   
            clippy::diverging_sub_expression
  124    124   
        )]
  125         -
        deserializer.read_struct(&CANCELSPOTFLEETREQUESTSINPUT_SCHEMA, (), |_, member, deser| {
         125  +
        deserializer.read_struct(&CANCELSPOTFLEETREQUESTSINPUT_SCHEMA, &mut |member, deser| {
  126    126   
            match member.member_index() {
  127    127   
                Some(0) => {
  128    128   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  129    129   
                }
  130    130   
                Some(1) => {
  131         -
                    builder.spot_fleet_request_ids = Some({
  132         -
                        let container = if let Some(cap) = deser.container_size() {
  133         -
                            Vec::with_capacity(cap)
  134         -
                        } else {
  135         -
                            Vec::new()
  136         -
                        };
  137         -
                        deser.read_list(member, container, |mut list, deser| {
  138         -
                            list.push(deser.read_string(member)?);
  139         -
                            Ok(list)
  140         -
                        })?
  141         -
                    });
         131  +
                    builder.spot_fleet_request_ids = Some(deser.read_string_list(member)?);
  142    132   
                }
  143    133   
                Some(2) => {
  144    134   
                    builder.terminate_instances = Some(deser.read_boolean(member)?);
  145    135   
                }
  146    136   
                _ => {}
  147    137   
            }
  148    138   
            Ok(())
  149    139   
        })?;
         140  +
        builder.spot_fleet_request_ids = builder.spot_fleet_request_ids.or(Some(Vec::new()));
         141  +
        builder.terminate_instances = builder.terminate_instances.or(Some(false));
  150    142   
        builder
  151    143   
            .build()
  152    144   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  153    145   
    }
  154    146   
}
         147  +
impl CancelSpotFleetRequestsInput {
         148  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         149  +
    pub fn deserialize_with_response(
         150  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         151  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         152  +
        _status: u16,
         153  +
        _body: &[u8],
         154  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         155  +
        Self::deserialize(deserializer)
         156  +
    }
         157  +
}
  155    158   
impl CancelSpotFleetRequestsInput {
  156    159   
    /// Creates a new builder-style object to manufacture [`CancelSpotFleetRequestsInput`](crate::operation::cancel_spot_fleet_requests::CancelSpotFleetRequestsInput).
  157    160   
    pub fn builder() -> crate::operation::cancel_spot_fleet_requests::builders::CancelSpotFleetRequestsInputBuilder {
  158    161   
        crate::operation::cancel_spot_fleet_requests::builders::CancelSpotFleetRequestsInputBuilder::default()
  159    162   
    }
  160    163   
}
  161    164   
  162    165   
/// A builder for [`CancelSpotFleetRequestsInput`](crate::operation::cancel_spot_fleet_requests::CancelSpotFleetRequestsInput).
  163    166   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  164    167   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/cancel_spot_fleet_requests/_cancel_spot_fleet_requests_output.rs

@@ -9,9 +166,222 @@
   29     29   
    "com.amazonaws.ec2.synthetic",
   30     30   
    "CancelSpotFleetRequestsOutput",
   31     31   
);
   32     32   
static CANCELSPOTFLEETREQUESTSOUTPUT_MEMBER_SUCCESSFUL_FLEET_REQUESTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static(
   34     34   
        "com.amazonaws.ec2.synthetic#CancelSpotFleetRequestsOutput$SuccessfulFleetRequests",
   35     35   
        "com.amazonaws.ec2.synthetic",
   36     36   
        "CancelSpotFleetRequestsOutput",
   37     37   
    ),
   38     38   
    ::aws_smithy_schema::ShapeType::List,
   39         -
    "successful_fleet_requests",
          39  +
    "SuccessfulFleetRequests",
   40     40   
    0,
   41     41   
)
   42     42   
.with_xml_name("successfulFleetRequestSet");
   43     43   
static CANCELSPOTFLEETREQUESTSOUTPUT_MEMBER_UNSUCCESSFUL_FLEET_REQUESTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.ec2.synthetic#CancelSpotFleetRequestsOutput$UnsuccessfulFleetRequests",
   46     46   
        "com.amazonaws.ec2.synthetic",
   47     47   
        "CancelSpotFleetRequestsOutput",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::List,
   50         -
    "unsuccessful_fleet_requests",
          50  +
    "UnsuccessfulFleetRequests",
   51     51   
    1,
   52     52   
)
   53     53   
.with_xml_name("unsuccessfulFleetRequestSet");
          54  +
static CANCELSPOTFLEETREQUESTSOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          55  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          56  +
    ::aws_smithy_schema::ShapeType::String,
          57  +
    "request_id",
          58  +
    2,
          59  +
)
          60  +
.with_http_header("x-amzn-requestid");
   54     61   
static CANCELSPOTFLEETREQUESTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   55     62   
    CANCELSPOTFLEETREQUESTSOUTPUT_SCHEMA_ID,
   56     63   
    ::aws_smithy_schema::ShapeType::Structure,
   57     64   
    &[
   58     65   
        &CANCELSPOTFLEETREQUESTSOUTPUT_MEMBER_SUCCESSFUL_FLEET_REQUESTS,
   59     66   
        &CANCELSPOTFLEETREQUESTSOUTPUT_MEMBER_UNSUCCESSFUL_FLEET_REQUESTS,
          67  +
        &CANCELSPOTFLEETREQUESTSOUTPUT_MEMBER__REQUEST_ID,
   60     68   
    ],
   61     69   
);
   62     70   
impl CancelSpotFleetRequestsOutput {
   63     71   
    /// The schema for this shape.
   64     72   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CANCELSPOTFLEETREQUESTSOUTPUT_SCHEMA;
   65     73   
}
   66     74   
impl ::aws_smithy_schema::serde::SerializableStruct for CancelSpotFleetRequestsOutput {
   67     75   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   68     76   
    fn serialize_members(
   69     77   
        &self,
   70     78   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   71     79   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   72     80   
        if let Some(ref val) = self.successful_fleet_requests {
   73     81   
            ser.write_list(
   74     82   
                &CANCELSPOTFLEETREQUESTSOUTPUT_MEMBER_SUCCESSFUL_FLEET_REQUESTS,
   75     83   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   76     84   
                    for item in val {
   77     85   
                        ser.write_struct(crate::types::CancelSpotFleetRequestsSuccessItem::SCHEMA, item)?;
   78     86   
                    }
   79     87   
                    Ok(())
   80     88   
                },
   81     89   
            )?;
   82     90   
        }
   83     91   
        if let Some(ref val) = self.unsuccessful_fleet_requests {
   84     92   
            ser.write_list(
   85     93   
                &CANCELSPOTFLEETREQUESTSOUTPUT_MEMBER_UNSUCCESSFUL_FLEET_REQUESTS,
   86     94   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   87     95   
                    for item in val {
   88     96   
                        ser.write_struct(crate::types::CancelSpotFleetRequestsErrorItem::SCHEMA, item)?;
   89     97   
                    }
   90     98   
                    Ok(())
   91     99   
                },
   92    100   
            )?;
   93    101   
        }
   94    102   
        Ok(())
   95    103   
    }
   96    104   
}
   97    105   
impl CancelSpotFleetRequestsOutput {
   98    106   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   99         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  100         -
        deserializer: &mut D,
         107  +
    pub fn deserialize(
         108  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         109  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         110  +
        #[allow(unused_variables, unused_mut)]
         111  +
        let mut builder = Self::builder();
         112  +
        #[allow(
         113  +
            unused_variables,
         114  +
            unreachable_code,
         115  +
            clippy::single_match,
         116  +
            clippy::match_single_binding,
         117  +
            clippy::diverging_sub_expression
         118  +
        )]
         119  +
        deserializer.read_struct(&CANCELSPOTFLEETREQUESTSOUTPUT_SCHEMA, &mut |member, deser| {
         120  +
            match member.member_index() {
         121  +
                Some(0) => {
         122  +
                    builder.successful_fleet_requests = Some({
         123  +
                        let mut container = Vec::new();
         124  +
                        deser.read_list(member, &mut |deser| {
         125  +
                            container.push(crate::types::CancelSpotFleetRequestsSuccessItem::deserialize(deser)?);
         126  +
                            Ok(())
         127  +
                        })?;
         128  +
                        container
         129  +
                    });
         130  +
                }
         131  +
                Some(1) => {
         132  +
                    builder.unsuccessful_fleet_requests = Some({
         133  +
                        let mut container = Vec::new();
         134  +
                        deser.read_list(member, &mut |deser| {
         135  +
                            container.push(crate::types::CancelSpotFleetRequestsErrorItem::deserialize(deser)?);
         136  +
                            Ok(())
         137  +
                        })?;
         138  +
                        container
         139  +
                    });
         140  +
                }
         141  +
                Some(2) => {
         142  +
                    builder._request_id = Some(deser.read_string(member)?);
         143  +
                }
         144  +
                _ => {}
         145  +
            }
         146  +
            Ok(())
         147  +
        })?;
         148  +
        Ok(builder.build())
         149  +
    }
         150  +
}
         151  +
impl CancelSpotFleetRequestsOutput {
         152  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         153  +
    /// Header-bound members are read directly from headers, avoiding runtime
         154  +
    /// member iteration overhead. Body members are read via the deserializer.
         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],
  101    160   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  102    161   
        #[allow(unused_variables, unused_mut)]
  103    162   
        let mut builder = Self::builder();
         163  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         164  +
            builder._request_id = Some(val.to_string());
         165  +
        }
  104    166   
        #[allow(
  105    167   
            unused_variables,
  106    168   
            unreachable_code,
  107    169   
            clippy::single_match,
  108    170   
            clippy::match_single_binding,
  109    171   
            clippy::diverging_sub_expression
  110    172   
        )]
  111         -
        deserializer.read_struct(&CANCELSPOTFLEETREQUESTSOUTPUT_SCHEMA, (), |_, member, deser| {
         173  +
        deserializer.read_struct(&CANCELSPOTFLEETREQUESTSOUTPUT_SCHEMA, &mut |member, deser| {
  112    174   
            match member.member_index() {
  113    175   
                Some(0) => {
  114    176   
                    builder.successful_fleet_requests = Some({
  115         -
                        let container = if let Some(cap) = deser.container_size() {
  116         -
                            Vec::with_capacity(cap)
  117         -
                        } else {
  118         -
                            Vec::new()
  119         -
                        };
  120         -
                        deser.read_list(member, container, |mut list, deser| {
  121         -
                            list.push(crate::types::CancelSpotFleetRequestsSuccessItem::deserialize(deser)?);
  122         -
                            Ok(list)
  123         -
                        })?
         177  +
                        let mut container = Vec::new();
         178  +
                        deser.read_list(member, &mut |deser| {
         179  +
                            container.push(crate::types::CancelSpotFleetRequestsSuccessItem::deserialize(deser)?);
         180  +
                            Ok(())
         181  +
                        })?;
         182  +
                        container
  124    183   
                    });
  125    184   
                }
  126    185   
                Some(1) => {
  127    186   
                    builder.unsuccessful_fleet_requests = Some({
  128         -
                        let container = if let Some(cap) = deser.container_size() {
  129         -
                            Vec::with_capacity(cap)
  130         -
                        } else {
  131         -
                            Vec::new()
  132         -
                        };
  133         -
                        deser.read_list(member, container, |mut list, deser| {
  134         -
                            list.push(crate::types::CancelSpotFleetRequestsErrorItem::deserialize(deser)?);
  135         -
                            Ok(list)
  136         -
                        })?
         187  +
                        let mut container = Vec::new();
         188  +
                        deser.read_list(member, &mut |deser| {
         189  +
                            container.push(crate::types::CancelSpotFleetRequestsErrorItem::deserialize(deser)?);
         190  +
                            Ok(())
         191  +
                        })?;
         192  +
                        container
  137    193   
                    });
  138    194   
                }
  139    195   
                _ => {}
  140    196   
            }
  141    197   
            Ok(())
  142    198   
        })?;
  143    199   
        Ok(builder.build())
  144    200   
    }
  145    201   
}
  146    202   
impl ::aws_types::request_id::RequestId for CancelSpotFleetRequestsOutput {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/cancel_spot_instance_requests.rs

@@ -1,1 +40,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `CancelSpotInstanceRequests`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CancelSpotInstanceRequests;
    6      6   
impl CancelSpotInstanceRequests {
    7      7   
    /// Creates a new `CancelSpotInstanceRequests`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::cancel_spot_instance_requests::CancelSpotInstanceRequestsInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::cancel_spot_instance_requests::CancelSpotInstanceRequestsOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::cancel_spot_instance_requests::CancelSpotInstanceRequestsInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::cancel_spot_instance_requests::CancelSpotInstanceRequestsOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::cancel_spot_instance_requests::CancelSpotInstanceRequestsError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -118,124 +180,187 @@
  138    144   
                crate::operation::cancel_spot_instance_requests::CancelSpotInstanceRequestsError,
  139    145   
            >::new());
  140    146   
  141    147   
        ::std::borrow::Cow::Owned(rcb)
  142    148   
    }
  143    149   
}
  144    150   
  145    151   
#[derive(Debug)]
  146    152   
struct CancelSpotInstanceRequestsResponseDeserializer;
  147    153   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CancelSpotInstanceRequestsResponseDeserializer {
  148         -
    fn deserialize_nonstreaming(
         154  +
    fn deserialize_nonstreaming_with_config(
  149    155   
        &self,
  150    156   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         157  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    158   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    159   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153    160   
        let headers = response.headers();
  154    161   
        let body = response.body().bytes().expect("body loaded");
  155    162   
        #[allow(unused_mut)]
  156    163   
        let mut force_error = false;
  157    164   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  158    165   
        let parse_result = if !success && status != 200 || force_error {
  159    166   
            crate::protocol_serde::shape_cancel_spot_instance_requests::de_cancel_spot_instance_requests_http_error(status, headers, body)
  160    167   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/cancel_spot_instance_requests/_cancel_spot_instance_requests_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/cancel_spot_instance_requests/_cancel_spot_instance_requests_output.rs

@@ -2,2 +121,172 @@
   22     22   
    "CancelSpotInstanceRequestsOutput",
   23     23   
);
   24     24   
static CANCELSPOTINSTANCEREQUESTSOUTPUT_MEMBER_CANCELLED_SPOT_INSTANCE_REQUESTS: ::aws_smithy_schema::Schema =
   25     25   
    ::aws_smithy_schema::Schema::new_member(
   26     26   
        ::aws_smithy_schema::ShapeId::from_static(
   27     27   
            "com.amazonaws.ec2.synthetic#CancelSpotInstanceRequestsOutput$CancelledSpotInstanceRequests",
   28     28   
            "com.amazonaws.ec2.synthetic",
   29     29   
            "CancelSpotInstanceRequestsOutput",
   30     30   
        ),
   31     31   
        ::aws_smithy_schema::ShapeType::List,
   32         -
        "cancelled_spot_instance_requests",
          32  +
        "CancelledSpotInstanceRequests",
   33     33   
        0,
   34     34   
    )
   35     35   
    .with_xml_name("spotInstanceRequestSet");
          36  +
static CANCELSPOTINSTANCEREQUESTSOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          37  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          38  +
    ::aws_smithy_schema::ShapeType::String,
          39  +
    "request_id",
          40  +
    1,
          41  +
)
          42  +
.with_http_header("x-amzn-requestid");
   36     43   
static CANCELSPOTINSTANCEREQUESTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   37     44   
    CANCELSPOTINSTANCEREQUESTSOUTPUT_SCHEMA_ID,
   38     45   
    ::aws_smithy_schema::ShapeType::Structure,
   39         -
    &[&CANCELSPOTINSTANCEREQUESTSOUTPUT_MEMBER_CANCELLED_SPOT_INSTANCE_REQUESTS],
          46  +
    &[
          47  +
        &CANCELSPOTINSTANCEREQUESTSOUTPUT_MEMBER_CANCELLED_SPOT_INSTANCE_REQUESTS,
          48  +
        &CANCELSPOTINSTANCEREQUESTSOUTPUT_MEMBER__REQUEST_ID,
          49  +
    ],
   40     50   
);
   41     51   
impl CancelSpotInstanceRequestsOutput {
   42     52   
    /// The schema for this shape.
   43     53   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CANCELSPOTINSTANCEREQUESTSOUTPUT_SCHEMA;
   44     54   
}
   45     55   
impl ::aws_smithy_schema::serde::SerializableStruct for CancelSpotInstanceRequestsOutput {
   46     56   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   47     57   
    fn serialize_members(
   48     58   
        &self,
   49     59   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   50     60   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   51     61   
        if let Some(ref val) = self.cancelled_spot_instance_requests {
   52     62   
            ser.write_list(
   53     63   
                &CANCELSPOTINSTANCEREQUESTSOUTPUT_MEMBER_CANCELLED_SPOT_INSTANCE_REQUESTS,
   54     64   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   55     65   
                    for item in val {
   56     66   
                        ser.write_struct(crate::types::CancelledSpotInstanceRequest::SCHEMA, item)?;
   57     67   
                    }
   58     68   
                    Ok(())
   59     69   
                },
   60     70   
            )?;
   61     71   
        }
   62     72   
        Ok(())
   63     73   
    }
   64     74   
}
   65     75   
impl CancelSpotInstanceRequestsOutput {
   66     76   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   67         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   68         -
        deserializer: &mut D,
          77  +
    pub fn deserialize(
          78  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          79  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          80  +
        #[allow(unused_variables, unused_mut)]
          81  +
        let mut builder = Self::builder();
          82  +
        #[allow(
          83  +
            unused_variables,
          84  +
            unreachable_code,
          85  +
            clippy::single_match,
          86  +
            clippy::match_single_binding,
          87  +
            clippy::diverging_sub_expression
          88  +
        )]
          89  +
        deserializer.read_struct(&CANCELSPOTINSTANCEREQUESTSOUTPUT_SCHEMA, &mut |member, deser| {
          90  +
            match member.member_index() {
          91  +
                Some(0) => {
          92  +
                    builder.cancelled_spot_instance_requests = Some({
          93  +
                        let mut container = Vec::new();
          94  +
                        deser.read_list(member, &mut |deser| {
          95  +
                            container.push(crate::types::CancelledSpotInstanceRequest::deserialize(deser)?);
          96  +
                            Ok(())
          97  +
                        })?;
          98  +
                        container
          99  +
                    });
         100  +
                }
         101  +
                Some(1) => {
         102  +
                    builder._request_id = Some(deser.read_string(member)?);
         103  +
                }
         104  +
                _ => {}
         105  +
            }
         106  +
            Ok(())
         107  +
        })?;
         108  +
        Ok(builder.build())
         109  +
    }
         110  +
}
         111  +
impl CancelSpotInstanceRequestsOutput {
         112  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         113  +
    /// Header-bound members are read directly from headers, avoiding runtime
         114  +
    /// member iteration overhead. Body members are read via the deserializer.
         115  +
    pub fn deserialize_with_response(
         116  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         117  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         118  +
        _status: u16,
         119  +
        _body: &[u8],
   69    120   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   70    121   
        #[allow(unused_variables, unused_mut)]
   71    122   
        let mut builder = Self::builder();
         123  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         124  +
            builder._request_id = Some(val.to_string());
         125  +
        }
   72    126   
        #[allow(
   73    127   
            unused_variables,
   74    128   
            unreachable_code,
   75    129   
            clippy::single_match,
   76    130   
            clippy::match_single_binding,
   77    131   
            clippy::diverging_sub_expression
   78    132   
        )]
   79         -
        deserializer.read_struct(&CANCELSPOTINSTANCEREQUESTSOUTPUT_SCHEMA, (), |_, member, deser| {
         133  +
        deserializer.read_struct(&CANCELSPOTINSTANCEREQUESTSOUTPUT_SCHEMA, &mut |member, deser| {
   80    134   
            match member.member_index() {
   81    135   
                Some(0) => {
   82    136   
                    builder.cancelled_spot_instance_requests = Some({
   83         -
                        let container = if let Some(cap) = deser.container_size() {
   84         -
                            Vec::with_capacity(cap)
   85         -
                        } else {
   86         -
                            Vec::new()
   87         -
                        };
   88         -
                        deser.read_list(member, container, |mut list, deser| {
   89         -
                            list.push(crate::types::CancelledSpotInstanceRequest::deserialize(deser)?);
   90         -
                            Ok(list)
   91         -
                        })?
         137  +
                        let mut container = Vec::new();
         138  +
                        deser.read_list(member, &mut |deser| {
         139  +
                            container.push(crate::types::CancelledSpotInstanceRequest::deserialize(deser)?);
         140  +
                            Ok(())
         141  +
                        })?;
         142  +
                        container
   92    143   
                    });
   93    144   
                }
   94    145   
                _ => {}
   95    146   
            }
   96    147   
            Ok(())
   97    148   
        })?;
   98    149   
        Ok(builder.build())
   99    150   
    }
  100    151   
}
  101    152   
impl ::aws_types::request_id::RequestId for CancelSpotInstanceRequestsOutput {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/confirm_product_instance.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `ConfirmProductInstance`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ConfirmProductInstance;
    6      6   
impl ConfirmProductInstance {
    7      7   
    /// Creates a new `ConfirmProductInstance`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::confirm_product_instance::ConfirmProductInstanceInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::confirm_product_instance::ConfirmProductInstanceOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::confirm_product_instance::ConfirmProductInstanceInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::confirm_product_instance::ConfirmProductInstanceOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::confirm_product_instance::ConfirmProductInstanceError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -118,122 +180,185 @@
  138    142   
                crate::operation::confirm_product_instance::ConfirmProductInstanceError,
  139    143   
            >::new());
  140    144   
  141    145   
        ::std::borrow::Cow::Owned(rcb)
  142    146   
    }
  143    147   
}
  144    148   
  145    149   
#[derive(Debug)]
  146    150   
struct ConfirmProductInstanceResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ConfirmProductInstanceResponseDeserializer {
  148         -
    fn deserialize_nonstreaming(
         152  +
    fn deserialize_nonstreaming_with_config(
  149    153   
        &self,
  150    154   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         155  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    156   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    157   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153    158   
        let headers = response.headers();
  154    159   
        let body = response.body().bytes().expect("body loaded");
  155    160   
        #[allow(unused_mut)]
  156    161   
        let mut force_error = false;
  157    162   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  158    163   
        let parse_result = if !success && status != 200 || force_error {
  159    164   
            crate::protocol_serde::shape_confirm_product_instance::de_confirm_product_instance_http_error(status, headers, body)
  160    165   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/confirm_product_instance/_confirm_product_instance_input.rs

@@ -9,9 +157,170 @@
   29     29   
    "com.amazonaws.ec2.synthetic",
   30     30   
    "ConfirmProductInstanceInput",
   31     31   
);
   32     32   
static CONFIRMPRODUCTINSTANCEINPUT_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static(
   34     34   
        "com.amazonaws.ec2.synthetic#ConfirmProductInstanceInput$InstanceId",
   35     35   
        "com.amazonaws.ec2.synthetic",
   36     36   
        "ConfirmProductInstanceInput",
   37     37   
    ),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "instance_id",
          39  +
    "InstanceId",
   40     40   
    0,
   41     41   
);
   42     42   
static CONFIRMPRODUCTINSTANCEINPUT_MEMBER_PRODUCT_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.ec2.synthetic#ConfirmProductInstanceInput$ProductCode",
   45     45   
        "com.amazonaws.ec2.synthetic",
   46     46   
        "ConfirmProductInstanceInput",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "product_code",
          49  +
    "ProductCode",
   50     50   
    1,
   51     51   
);
   52     52   
static CONFIRMPRODUCTINSTANCEINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.ec2.synthetic#ConfirmProductInstanceInput$DryRun",
   55     55   
        "com.amazonaws.ec2.synthetic",
   56     56   
        "ConfirmProductInstanceInput",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::Boolean,
   59         -
    "dry_run",
          59  +
    "DryRun",
   60     60   
    2,
   61     61   
)
   62     62   
.with_xml_name("dryRun");
   63     63   
static CONFIRMPRODUCTINSTANCEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    CONFIRMPRODUCTINSTANCEINPUT_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &CONFIRMPRODUCTINSTANCEINPUT_MEMBER_INSTANCE_ID,
   68     68   
        &CONFIRMPRODUCTINSTANCEINPUT_MEMBER_PRODUCT_CODE,
   69     69   
        &CONFIRMPRODUCTINSTANCEINPUT_MEMBER_DRY_RUN,
   70     70   
    ],
   71     71   
);
   72     72   
impl ConfirmProductInstanceInput {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONFIRMPRODUCTINSTANCEINPUT_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for ConfirmProductInstanceInput {
   77     77   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   78     78   
    fn serialize_members(
   79     79   
        &self,
   80     80   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   81     81   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   82     82   
        if let Some(ref val) = self.instance_id {
   83     83   
            ser.write_string(&CONFIRMPRODUCTINSTANCEINPUT_MEMBER_INSTANCE_ID, val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.product_code {
   86     86   
            ser.write_string(&CONFIRMPRODUCTINSTANCEINPUT_MEMBER_PRODUCT_CODE, val)?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.dry_run {
   89     89   
            ser.write_boolean(&CONFIRMPRODUCTINSTANCEINPUT_MEMBER_DRY_RUN, *val)?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl ConfirmProductInstanceInput {
   95     95   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   96         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   97         -
        deserializer: &mut D,
          96  +
    pub fn deserialize(
          97  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   98     98   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   99     99   
        #[allow(unused_variables, unused_mut)]
  100    100   
        let mut builder = Self::builder();
  101    101   
        #[allow(
  102    102   
            unused_variables,
  103    103   
            unreachable_code,
  104    104   
            clippy::single_match,
  105    105   
            clippy::match_single_binding,
  106    106   
            clippy::diverging_sub_expression
  107    107   
        )]
  108         -
        deserializer.read_struct(&CONFIRMPRODUCTINSTANCEINPUT_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&CONFIRMPRODUCTINSTANCEINPUT_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.instance_id = Some(deser.read_string(member)?);
  112    112   
                }
  113    113   
                Some(1) => {
  114    114   
                    builder.product_code = Some(deser.read_string(member)?);
  115    115   
                }
  116    116   
                Some(2) => {
  117    117   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  118    118   
                }
  119    119   
                _ => {}
  120    120   
            }
  121    121   
            Ok(())
  122    122   
        })?;
         123  +
        builder.instance_id = builder.instance_id.or(Some(String::new()));
         124  +
        builder.product_code = builder.product_code.or(Some(String::new()));
  123    125   
        builder
  124    126   
            .build()
  125    127   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  126    128   
    }
  127    129   
}
         130  +
impl ConfirmProductInstanceInput {
         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  +
}
  128    141   
impl ConfirmProductInstanceInput {
  129    142   
    /// Creates a new builder-style object to manufacture [`ConfirmProductInstanceInput`](crate::operation::confirm_product_instance::ConfirmProductInstanceInput).
  130    143   
    pub fn builder() -> crate::operation::confirm_product_instance::builders::ConfirmProductInstanceInputBuilder {
  131    144   
        crate::operation::confirm_product_instance::builders::ConfirmProductInstanceInputBuilder::default()
  132    145   
    }
  133    146   
}
  134    147   
  135    148   
/// A builder for [`ConfirmProductInstanceInput`](crate::operation::confirm_product_instance::ConfirmProductInstanceInput).
  136    149   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  137    150   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/confirm_product_instance/_confirm_product_instance_output.rs

@@ -4,4 +117,168 @@
   24     24   
    "com.amazonaws.ec2.synthetic",
   25     25   
    "ConfirmProductInstanceOutput",
   26     26   
);
   27     27   
static CONFIRMPRODUCTINSTANCEOUTPUT_MEMBER_RETURN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.ec2.synthetic#ConfirmProductInstanceOutput$Return",
   30     30   
        "com.amazonaws.ec2.synthetic",
   31     31   
        "ConfirmProductInstanceOutput",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::Boolean,
   34         -
    "r##return",
          34  +
    "Return",
   35     35   
    0,
   36     36   
)
   37     37   
.with_xml_name("return");
   38     38   
static CONFIRMPRODUCTINSTANCEOUTPUT_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.synthetic#ConfirmProductInstanceOutput$OwnerId",
   41     41   
        "com.amazonaws.ec2.synthetic",
   42     42   
        "ConfirmProductInstanceOutput",
   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  +
static CONFIRMPRODUCTINSTANCEOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          50  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          51  +
    ::aws_smithy_schema::ShapeType::String,
          52  +
    "request_id",
          53  +
    2,
          54  +
)
          55  +
.with_http_header("x-amzn-requestid");
   49     56   
static CONFIRMPRODUCTINSTANCEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     57   
    CONFIRMPRODUCTINSTANCEOUTPUT_SCHEMA_ID,
   51     58   
    ::aws_smithy_schema::ShapeType::Structure,
   52         -
    &[&CONFIRMPRODUCTINSTANCEOUTPUT_MEMBER_RETURN, &CONFIRMPRODUCTINSTANCEOUTPUT_MEMBER_OWNER_ID],
          59  +
    &[
          60  +
        &CONFIRMPRODUCTINSTANCEOUTPUT_MEMBER_RETURN,
          61  +
        &CONFIRMPRODUCTINSTANCEOUTPUT_MEMBER_OWNER_ID,
          62  +
        &CONFIRMPRODUCTINSTANCEOUTPUT_MEMBER__REQUEST_ID,
          63  +
    ],
   53     64   
);
   54     65   
impl ConfirmProductInstanceOutput {
   55     66   
    /// The schema for this shape.
   56     67   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONFIRMPRODUCTINSTANCEOUTPUT_SCHEMA;
   57     68   
}
   58     69   
impl ::aws_smithy_schema::serde::SerializableStruct for ConfirmProductInstanceOutput {
   59     70   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   60     71   
    fn serialize_members(
   61     72   
        &self,
   62     73   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   63     74   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   64     75   
        if let Some(ref val) = self.r#return {
   65     76   
            ser.write_boolean(&CONFIRMPRODUCTINSTANCEOUTPUT_MEMBER_RETURN, *val)?;
   66     77   
        }
   67     78   
        if let Some(ref val) = self.owner_id {
   68     79   
            ser.write_string(&CONFIRMPRODUCTINSTANCEOUTPUT_MEMBER_OWNER_ID, val)?;
   69     80   
        }
   70     81   
        Ok(())
   71     82   
    }
   72     83   
}
   73     84   
impl ConfirmProductInstanceOutput {
   74     85   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   75         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   76         -
        deserializer: &mut D,
          86  +
    pub fn deserialize(
          87  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   77     88   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   78     89   
        #[allow(unused_variables, unused_mut)]
   79     90   
        let mut builder = Self::builder();
   80     91   
        #[allow(
   81     92   
            unused_variables,
   82     93   
            unreachable_code,
   83     94   
            clippy::single_match,
   84     95   
            clippy::match_single_binding,
   85     96   
            clippy::diverging_sub_expression
   86     97   
        )]
   87         -
        deserializer.read_struct(&CONFIRMPRODUCTINSTANCEOUTPUT_SCHEMA, (), |_, member, deser| {
          98  +
        deserializer.read_struct(&CONFIRMPRODUCTINSTANCEOUTPUT_SCHEMA, &mut |member, deser| {
          99  +
            match member.member_index() {
         100  +
                Some(0) => {
         101  +
                    builder.r#return = Some(deser.read_boolean(member)?);
         102  +
                }
         103  +
                Some(1) => {
         104  +
                    builder.owner_id = Some(deser.read_string(member)?);
         105  +
                }
         106  +
                Some(2) => {
         107  +
                    builder._request_id = Some(deser.read_string(member)?);
         108  +
                }
         109  +
                _ => {}
         110  +
            }
         111  +
            Ok(())
         112  +
        })?;
         113  +
        Ok(builder.build())
         114  +
    }
         115  +
}
         116  +
impl ConfirmProductInstanceOutput {
         117  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         118  +
    /// Header-bound members are read directly from headers, avoiding runtime
         119  +
    /// member iteration overhead. Body members are read via the deserializer.
         120  +
    pub fn deserialize_with_response(
         121  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         122  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         123  +
        _status: u16,
         124  +
        _body: &[u8],
         125  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         126  +
        #[allow(unused_variables, unused_mut)]
         127  +
        let mut builder = Self::builder();
         128  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         129  +
            builder._request_id = Some(val.to_string());
         130  +
        }
         131  +
        #[allow(
         132  +
            unused_variables,
         133  +
            unreachable_code,
         134  +
            clippy::single_match,
         135  +
            clippy::match_single_binding,
         136  +
            clippy::diverging_sub_expression
         137  +
        )]
         138  +
        deserializer.read_struct(&CONFIRMPRODUCTINSTANCEOUTPUT_SCHEMA, &mut |member, deser| {
   88    139   
            match member.member_index() {
   89    140   
                Some(0) => {
   90    141   
                    builder.r#return = Some(deser.read_boolean(member)?);
   91    142   
                }
   92    143   
                Some(1) => {
   93    144   
                    builder.owner_id = Some(deser.read_string(member)?);
   94    145   
                }
   95    146   
                _ => {}
   96    147   
            }
   97    148   
            Ok(())

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/copy_fpga_image.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `CopyFpgaImage`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CopyFpgaImage;
    6      6   
impl CopyFpgaImage {
    7      7   
    /// Creates a new `CopyFpgaImage`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::copy_fpga_image::CopyFpgaImageInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::copy_fpga_image::CopyFpgaImageOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::copy_fpga_image::CopyFpgaImageInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::copy_fpga_image::CopyFpgaImageOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::copy_fpga_image::CopyFpgaImageError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -115,119 +177,182 @@
  135    139   
                crate::operation::copy_fpga_image::CopyFpgaImageError,
  136    140   
            >::new());
  137    141   
  138    142   
        ::std::borrow::Cow::Owned(rcb)
  139    143   
    }
  140    144   
}
  141    145   
  142    146   
#[derive(Debug)]
  143    147   
struct CopyFpgaImageResponseDeserializer;
  144    148   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CopyFpgaImageResponseDeserializer {
  145         -
    fn deserialize_nonstreaming(
         149  +
    fn deserialize_nonstreaming_with_config(
  146    150   
        &self,
  147    151   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         152  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  148    153   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  149    154   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  150    155   
        let headers = response.headers();
  151    156   
        let body = response.body().bytes().expect("body loaded");
  152    157   
        #[allow(unused_mut)]
  153    158   
        let mut force_error = false;
  154    159   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  155    160   
        let parse_result = if !success && status != 200 || force_error {
  156    161   
            crate::protocol_serde::shape_copy_fpga_image::de_copy_fpga_image_http_error(status, headers, body)
  157    162   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/copy_fpga_image/_copy_fpga_image_input.rs

@@ -27,27 +225,238 @@
   47     47   
    "com.amazonaws.ec2.synthetic",
   48     48   
    "CopyFpgaImageInput",
   49     49   
);
   50     50   
static COPYFPGAIMAGEINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.ec2.synthetic#CopyFpgaImageInput$DryRun",
   53     53   
        "com.amazonaws.ec2.synthetic",
   54     54   
        "CopyFpgaImageInput",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::Boolean,
   57         -
    "dry_run",
          57  +
    "DryRun",
   58     58   
    0,
   59     59   
);
   60     60   
static COPYFPGAIMAGEINPUT_MEMBER_SOURCE_FPGA_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.ec2.synthetic#CopyFpgaImageInput$SourceFpgaImageId",
   63     63   
        "com.amazonaws.ec2.synthetic",
   64     64   
        "CopyFpgaImageInput",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::String,
   67         -
    "source_fpga_image_id",
          67  +
    "SourceFpgaImageId",
   68     68   
    1,
   69     69   
);
   70     70   
static COPYFPGAIMAGEINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.ec2.synthetic#CopyFpgaImageInput$Description",
   73     73   
        "com.amazonaws.ec2.synthetic",
   74     74   
        "CopyFpgaImageInput",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "description",
          77  +
    "Description",
   78     78   
    2,
   79     79   
);
   80     80   
static COPYFPGAIMAGEINPUT_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static(
   82     82   
        "com.amazonaws.ec2.synthetic#CopyFpgaImageInput$Name",
   83     83   
        "com.amazonaws.ec2.synthetic",
   84     84   
        "CopyFpgaImageInput",
   85     85   
    ),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "name",
          87  +
    "Name",
   88     88   
    3,
   89     89   
);
   90     90   
static COPYFPGAIMAGEINPUT_MEMBER_SOURCE_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.ec2.synthetic#CopyFpgaImageInput$SourceRegion",
   93     93   
        "com.amazonaws.ec2.synthetic",
   94     94   
        "CopyFpgaImageInput",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::String,
   97         -
    "source_region",
          97  +
    "SourceRegion",
   98     98   
    4,
   99     99   
);
  100    100   
static COPYFPGAIMAGEINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.ec2.synthetic#CopyFpgaImageInput$ClientToken",
  103    103   
        "com.amazonaws.ec2.synthetic",
  104    104   
        "CopyFpgaImageInput",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::String,
  107         -
    "client_token",
         107  +
    "ClientToken",
  108    108   
    5,
  109    109   
);
  110    110   
static COPYFPGAIMAGEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  111    111   
    COPYFPGAIMAGEINPUT_SCHEMA_ID,
  112    112   
    ::aws_smithy_schema::ShapeType::Structure,
  113    113   
    &[
  114    114   
        &COPYFPGAIMAGEINPUT_MEMBER_DRY_RUN,
  115    115   
        &COPYFPGAIMAGEINPUT_MEMBER_SOURCE_FPGA_IMAGE_ID,
  116    116   
        &COPYFPGAIMAGEINPUT_MEMBER_DESCRIPTION,
  117    117   
        &COPYFPGAIMAGEINPUT_MEMBER_NAME,
  118    118   
        &COPYFPGAIMAGEINPUT_MEMBER_SOURCE_REGION,
  119    119   
        &COPYFPGAIMAGEINPUT_MEMBER_CLIENT_TOKEN,
  120    120   
    ],
  121    121   
);
  122    122   
impl CopyFpgaImageInput {
  123    123   
    /// The schema for this shape.
  124    124   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COPYFPGAIMAGEINPUT_SCHEMA;
  125    125   
}
  126    126   
impl ::aws_smithy_schema::serde::SerializableStruct for CopyFpgaImageInput {
  127    127   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  128    128   
    fn serialize_members(
  129    129   
        &self,
  130    130   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  131    131   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  132    132   
        if let Some(ref val) = self.dry_run {
  133    133   
            ser.write_boolean(&COPYFPGAIMAGEINPUT_MEMBER_DRY_RUN, *val)?;
  134    134   
        }
  135    135   
        if let Some(ref val) = self.source_fpga_image_id {
  136    136   
            ser.write_string(&COPYFPGAIMAGEINPUT_MEMBER_SOURCE_FPGA_IMAGE_ID, val)?;
  137    137   
        }
  138    138   
        if let Some(ref val) = self.description {
  139    139   
            ser.write_string(&COPYFPGAIMAGEINPUT_MEMBER_DESCRIPTION, val)?;
  140    140   
        }
  141    141   
        if let Some(ref val) = self.name {
  142    142   
            ser.write_string(&COPYFPGAIMAGEINPUT_MEMBER_NAME, val)?;
  143    143   
        }
  144    144   
        if let Some(ref val) = self.source_region {
  145    145   
            ser.write_string(&COPYFPGAIMAGEINPUT_MEMBER_SOURCE_REGION, val)?;
  146    146   
        }
  147    147   
        if let Some(ref val) = self.client_token {
  148    148   
            ser.write_string(&COPYFPGAIMAGEINPUT_MEMBER_CLIENT_TOKEN, val)?;
  149    149   
        }
  150    150   
        Ok(())
  151    151   
    }
  152    152   
}
  153    153   
impl CopyFpgaImageInput {
  154    154   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  155         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  156         -
        deserializer: &mut D,
         155  +
    pub fn deserialize(
         156  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  157    157   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  158    158   
        #[allow(unused_variables, unused_mut)]
  159    159   
        let mut builder = Self::builder();
  160    160   
        #[allow(
  161    161   
            unused_variables,
  162    162   
            unreachable_code,
  163    163   
            clippy::single_match,
  164    164   
            clippy::match_single_binding,
  165    165   
            clippy::diverging_sub_expression
  166    166   
        )]
  167         -
        deserializer.read_struct(&COPYFPGAIMAGEINPUT_SCHEMA, (), |_, member, deser| {
         167  +
        deserializer.read_struct(&COPYFPGAIMAGEINPUT_SCHEMA, &mut |member, deser| {
  168    168   
            match member.member_index() {
  169    169   
                Some(0) => {
  170    170   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  171    171   
                }
  172    172   
                Some(1) => {
  173    173   
                    builder.source_fpga_image_id = Some(deser.read_string(member)?);
  174    174   
                }
  175    175   
                Some(2) => {
  176    176   
                    builder.description = Some(deser.read_string(member)?);
  177    177   
                }
  178    178   
                Some(3) => {
  179    179   
                    builder.name = Some(deser.read_string(member)?);
  180    180   
                }
  181    181   
                Some(4) => {
  182    182   
                    builder.source_region = Some(deser.read_string(member)?);
  183    183   
                }
  184    184   
                Some(5) => {
  185    185   
                    builder.client_token = Some(deser.read_string(member)?);
  186    186   
                }
  187    187   
                _ => {}
  188    188   
            }
  189    189   
            Ok(())
  190    190   
        })?;
         191  +
        builder.source_fpga_image_id = builder.source_fpga_image_id.or(Some(String::new()));
         192  +
        builder.source_region = builder.source_region.or(Some(String::new()));
  191    193   
        builder
  192    194   
            .build()
  193    195   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  194    196   
    }
  195    197   
}
         198  +
impl CopyFpgaImageInput {
         199  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         200  +
    pub fn deserialize_with_response(
         201  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         202  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         203  +
        _status: u16,
         204  +
        _body: &[u8],
         205  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         206  +
        Self::deserialize(deserializer)
         207  +
    }
         208  +
}
  196    209   
impl CopyFpgaImageInput {
  197    210   
    /// Creates a new builder-style object to manufacture [`CopyFpgaImageInput`](crate::operation::copy_fpga_image::CopyFpgaImageInput).
  198    211   
    pub fn builder() -> crate::operation::copy_fpga_image::builders::CopyFpgaImageInputBuilder {
  199    212   
        crate::operation::copy_fpga_image::builders::CopyFpgaImageInputBuilder::default()
  200    213   
    }
  201    214   
}
  202    215   
  203    216   
/// A builder for [`CopyFpgaImageInput`](crate::operation::copy_fpga_image::CopyFpgaImageInput).
  204    217   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  205    218   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/copy_fpga_image/_copy_fpga_image_output.rs

@@ -1,1 +97,141 @@
   18     18   
    "com.amazonaws.ec2.synthetic",
   19     19   
    "CopyFpgaImageOutput",
   20     20   
);
   21     21   
static COPYFPGAIMAGEOUTPUT_MEMBER_FPGA_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.ec2.synthetic#CopyFpgaImageOutput$FpgaImageId",
   24     24   
        "com.amazonaws.ec2.synthetic",
   25     25   
        "CopyFpgaImageOutput",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::String,
   28         -
    "fpga_image_id",
          28  +
    "FpgaImageId",
   29     29   
    0,
   30     30   
)
   31     31   
.with_xml_name("fpgaImageId");
          32  +
static COPYFPGAIMAGEOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          33  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          34  +
    ::aws_smithy_schema::ShapeType::String,
          35  +
    "request_id",
          36  +
    1,
          37  +
)
          38  +
.with_http_header("x-amzn-requestid");
   32     39   
static COPYFPGAIMAGEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     40   
    COPYFPGAIMAGEOUTPUT_SCHEMA_ID,
   34     41   
    ::aws_smithy_schema::ShapeType::Structure,
   35         -
    &[&COPYFPGAIMAGEOUTPUT_MEMBER_FPGA_IMAGE_ID],
          42  +
    &[&COPYFPGAIMAGEOUTPUT_MEMBER_FPGA_IMAGE_ID, &COPYFPGAIMAGEOUTPUT_MEMBER__REQUEST_ID],
   36     43   
);
   37     44   
impl CopyFpgaImageOutput {
   38     45   
    /// The schema for this shape.
   39     46   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COPYFPGAIMAGEOUTPUT_SCHEMA;
   40     47   
}
   41     48   
impl ::aws_smithy_schema::serde::SerializableStruct for CopyFpgaImageOutput {
   42     49   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   43     50   
    fn serialize_members(
   44     51   
        &self,
   45     52   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   46     53   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     54   
        if let Some(ref val) = self.fpga_image_id {
   48     55   
            ser.write_string(&COPYFPGAIMAGEOUTPUT_MEMBER_FPGA_IMAGE_ID, val)?;
   49     56   
        }
   50     57   
        Ok(())
   51     58   
    }
   52     59   
}
   53     60   
impl CopyFpgaImageOutput {
   54     61   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   55         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   56         -
        deserializer: &mut D,
          62  +
    pub fn deserialize(
          63  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          64  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          65  +
        #[allow(unused_variables, unused_mut)]
          66  +
        let mut builder = Self::builder();
          67  +
        #[allow(
          68  +
            unused_variables,
          69  +
            unreachable_code,
          70  +
            clippy::single_match,
          71  +
            clippy::match_single_binding,
          72  +
            clippy::diverging_sub_expression
          73  +
        )]
          74  +
        deserializer.read_struct(&COPYFPGAIMAGEOUTPUT_SCHEMA, &mut |member, deser| {
          75  +
            match member.member_index() {
          76  +
                Some(0) => {
          77  +
                    builder.fpga_image_id = Some(deser.read_string(member)?);
          78  +
                }
          79  +
                Some(1) => {
          80  +
                    builder._request_id = Some(deser.read_string(member)?);
          81  +
                }
          82  +
                _ => {}
          83  +
            }
          84  +
            Ok(())
          85  +
        })?;
          86  +
        Ok(builder.build())
          87  +
    }
          88  +
}
          89  +
impl CopyFpgaImageOutput {
          90  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          91  +
    /// Header-bound members are read directly from headers, avoiding runtime
          92  +
    /// member iteration overhead. Body members are read via the deserializer.
          93  +
    pub fn deserialize_with_response(
          94  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          95  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          96  +
        _status: u16,
          97  +
        _body: &[u8],
   57     98   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   58     99   
        #[allow(unused_variables, unused_mut)]
   59    100   
        let mut builder = Self::builder();
         101  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         102  +
            builder._request_id = Some(val.to_string());
         103  +
        }
   60    104   
        #[allow(
   61    105   
            unused_variables,
   62    106   
            unreachable_code,
   63    107   
            clippy::single_match,
   64    108   
            clippy::match_single_binding,
   65    109   
            clippy::diverging_sub_expression
   66    110   
        )]
   67         -
        deserializer.read_struct(&COPYFPGAIMAGEOUTPUT_SCHEMA, (), |_, member, deser| {
         111  +
        deserializer.read_struct(&COPYFPGAIMAGEOUTPUT_SCHEMA, &mut |member, deser| {
   68    112   
            match member.member_index() {
   69    113   
                Some(0) => {
   70    114   
                    builder.fpga_image_id = Some(deser.read_string(member)?);
   71    115   
                }
   72    116   
                _ => {}
   73    117   
            }
   74    118   
            Ok(())
   75    119   
        })?;
   76    120   
        Ok(builder.build())
   77    121   
    }