AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/import_client_vpn_client_certificate_revocation_list.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 `ImportClientVpnClientCertificateRevocationList`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ImportClientVpnClientCertificateRevocationList;
    6      6   
impl ImportClientVpnClientCertificateRevocationList {
    7      7   
    /// Creates a new `ImportClientVpnClientCertificateRevocationList`
    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::import_client_vpn_client_certificate_revocation_list::ImportClientVpnClientCertificateRevocationListInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::import_client_vpn_client_certificate_revocation_list::ImportClientVpnClientCertificateRevocationListOutput::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::import_client_vpn_client_certificate_revocation_list::ImportClientVpnClientCertificateRevocationListInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::import_client_vpn_client_certificate_revocation_list::ImportClientVpnClientCertificateRevocationListOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::import_client_vpn_client_certificate_revocation_list::ImportClientVpnClientCertificateRevocationListError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -120,126 +182,189 @@
  140    146   
                    crate::operation::import_client_vpn_client_certificate_revocation_list::ImportClientVpnClientCertificateRevocationListError,
  141    147   
                >::new());
  142    148   
  143    149   
        ::std::borrow::Cow::Owned(rcb)
  144    150   
    }
  145    151   
}
  146    152   
  147    153   
#[derive(Debug)]
  148    154   
struct ImportClientVpnClientCertificateRevocationListResponseDeserializer;
  149    155   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ImportClientVpnClientCertificateRevocationListResponseDeserializer {
  150         -
    fn deserialize_nonstreaming(
         156  +
    fn deserialize_nonstreaming_with_config(
  151    157   
        &self,
  152    158   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         159  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  153    160   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  154    161   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  155    162   
        let headers = response.headers();
  156    163   
        let body = response.body().bytes().expect("body loaded");
  157    164   
        #[allow(unused_mut)]
  158    165   
        let mut force_error = false;
  159    166   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  160    167   
        let parse_result = if !success && status != 200 || force_error {
  161    168   
            crate::protocol_serde::shape_import_client_vpn_client_certificate_revocation_list::de_import_client_vpn_client_certificate_revocation_list_http_error(status, headers, body)
  162    169   
        } else {

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

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

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

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/import_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 `ImportImage`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ImportImage;
    6      6   
impl ImportImage {
    7      7   
    /// Creates a new `ImportImage`
    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::import_image::ImportImageInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::import_image::ImportImageOutput::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::import_image::ImportImageInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::import_image::ImportImageOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::import_image::ImportImageError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -116,120 +178,183 @@
  136    140   
                crate::operation::import_image::ImportImageError,
  137    141   
            >::new());
  138    142   
  139    143   
        ::std::borrow::Cow::Owned(rcb)
  140    144   
    }
  141    145   
}
  142    146   
  143    147   
#[derive(Debug)]
  144    148   
struct ImportImageResponseDeserializer;
  145    149   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ImportImageResponseDeserializer {
  146         -
    fn deserialize_nonstreaming(
         150  +
    fn deserialize_nonstreaming_with_config(
  147    151   
        &self,
  148    152   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         153  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  149    154   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  150    155   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  151    156   
        let headers = response.headers();
  152    157   
        let body = response.body().bytes().expect("body loaded");
  153    158   
        #[allow(unused_mut)]
  154    159   
        let mut force_error = false;
  155    160   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  156    161   
        let parse_result = if !success && status != 200 || force_error {
  157    162   
            crate::protocol_serde::shape_import_image::de_import_image_http_error(status, headers, body)
  158    163   
        } else {

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

@@ -135,135 +347,347 @@
  155    155   
    "com.amazonaws.ec2.synthetic",
  156    156   
    "ImportImageInput",
  157    157   
);
  158    158   
static IMPORTIMAGEINPUT_MEMBER_ARCHITECTURE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  159    159   
    ::aws_smithy_schema::ShapeId::from_static(
  160    160   
        "com.amazonaws.ec2.synthetic#ImportImageInput$Architecture",
  161    161   
        "com.amazonaws.ec2.synthetic",
  162    162   
        "ImportImageInput",
  163    163   
    ),
  164    164   
    ::aws_smithy_schema::ShapeType::String,
  165         -
    "architecture",
         165  +
    "Architecture",
  166    166   
    0,
  167    167   
);
  168    168   
static IMPORTIMAGEINPUT_MEMBER_CLIENT_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  169    169   
    ::aws_smithy_schema::ShapeId::from_static(
  170    170   
        "com.amazonaws.ec2.synthetic#ImportImageInput$ClientData",
  171    171   
        "com.amazonaws.ec2.synthetic",
  172    172   
        "ImportImageInput",
  173    173   
    ),
  174    174   
    ::aws_smithy_schema::ShapeType::Structure,
  175         -
    "client_data",
         175  +
    "ClientData",
  176    176   
    1,
  177    177   
);
  178    178   
static IMPORTIMAGEINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static(
  180    180   
        "com.amazonaws.ec2.synthetic#ImportImageInput$ClientToken",
  181    181   
        "com.amazonaws.ec2.synthetic",
  182    182   
        "ImportImageInput",
  183    183   
    ),
  184    184   
    ::aws_smithy_schema::ShapeType::String,
  185         -
    "client_token",
         185  +
    "ClientToken",
  186    186   
    2,
  187    187   
);
  188    188   
static IMPORTIMAGEINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  189    189   
    ::aws_smithy_schema::ShapeId::from_static(
  190    190   
        "com.amazonaws.ec2.synthetic#ImportImageInput$Description",
  191    191   
        "com.amazonaws.ec2.synthetic",
  192    192   
        "ImportImageInput",
  193    193   
    ),
  194    194   
    ::aws_smithy_schema::ShapeType::String,
  195         -
    "description",
         195  +
    "Description",
  196    196   
    3,
  197    197   
);
  198    198   
static IMPORTIMAGEINPUT_MEMBER_DISK_CONTAINERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  199    199   
    ::aws_smithy_schema::ShapeId::from_static(
  200    200   
        "com.amazonaws.ec2.synthetic#ImportImageInput$DiskContainers",
  201    201   
        "com.amazonaws.ec2.synthetic",
  202    202   
        "ImportImageInput",
  203    203   
    ),
  204    204   
    ::aws_smithy_schema::ShapeType::List,
  205         -
    "disk_containers",
         205  +
    "DiskContainers",
  206    206   
    4,
  207    207   
)
  208    208   
.with_xml_name("DiskContainer");
  209    209   
static IMPORTIMAGEINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  210    210   
    ::aws_smithy_schema::ShapeId::from_static(
  211    211   
        "com.amazonaws.ec2.synthetic#ImportImageInput$DryRun",
  212    212   
        "com.amazonaws.ec2.synthetic",
  213    213   
        "ImportImageInput",
  214    214   
    ),
  215    215   
    ::aws_smithy_schema::ShapeType::Boolean,
  216         -
    "dry_run",
         216  +
    "DryRun",
  217    217   
    5,
  218    218   
);
  219    219   
static IMPORTIMAGEINPUT_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  220    220   
    ::aws_smithy_schema::ShapeId::from_static(
  221    221   
        "com.amazonaws.ec2.synthetic#ImportImageInput$Encrypted",
  222    222   
        "com.amazonaws.ec2.synthetic",
  223    223   
        "ImportImageInput",
  224    224   
    ),
  225    225   
    ::aws_smithy_schema::ShapeType::Boolean,
  226         -
    "encrypted",
         226  +
    "Encrypted",
  227    227   
    6,
  228    228   
);
  229    229   
static IMPORTIMAGEINPUT_MEMBER_HYPERVISOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  230    230   
    ::aws_smithy_schema::ShapeId::from_static(
  231    231   
        "com.amazonaws.ec2.synthetic#ImportImageInput$Hypervisor",
  232    232   
        "com.amazonaws.ec2.synthetic",
  233    233   
        "ImportImageInput",
  234    234   
    ),
  235    235   
    ::aws_smithy_schema::ShapeType::String,
  236         -
    "hypervisor",
         236  +
    "Hypervisor",
  237    237   
    7,
  238    238   
);
  239    239   
static IMPORTIMAGEINPUT_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  240    240   
    ::aws_smithy_schema::ShapeId::from_static(
  241    241   
        "com.amazonaws.ec2.synthetic#ImportImageInput$KmsKeyId",
  242    242   
        "com.amazonaws.ec2.synthetic",
  243    243   
        "ImportImageInput",
  244    244   
    ),
  245    245   
    ::aws_smithy_schema::ShapeType::String,
  246         -
    "kms_key_id",
         246  +
    "KmsKeyId",
  247    247   
    8,
  248    248   
);
  249    249   
static IMPORTIMAGEINPUT_MEMBER_LICENSE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  250    250   
    ::aws_smithy_schema::ShapeId::from_static(
  251    251   
        "com.amazonaws.ec2.synthetic#ImportImageInput$LicenseType",
  252    252   
        "com.amazonaws.ec2.synthetic",
  253    253   
        "ImportImageInput",
  254    254   
    ),
  255    255   
    ::aws_smithy_schema::ShapeType::String,
  256         -
    "license_type",
         256  +
    "LicenseType",
  257    257   
    9,
  258    258   
);
  259    259   
static IMPORTIMAGEINPUT_MEMBER_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  260    260   
    ::aws_smithy_schema::ShapeId::from_static(
  261    261   
        "com.amazonaws.ec2.synthetic#ImportImageInput$Platform",
  262    262   
        "com.amazonaws.ec2.synthetic",
  263    263   
        "ImportImageInput",
  264    264   
    ),
  265    265   
    ::aws_smithy_schema::ShapeType::String,
  266         -
    "platform",
         266  +
    "Platform",
  267    267   
    10,
  268    268   
);
  269    269   
static IMPORTIMAGEINPUT_MEMBER_ROLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  270    270   
    ::aws_smithy_schema::ShapeId::from_static(
  271    271   
        "com.amazonaws.ec2.synthetic#ImportImageInput$RoleName",
  272    272   
        "com.amazonaws.ec2.synthetic",
  273    273   
        "ImportImageInput",
  274    274   
    ),
  275    275   
    ::aws_smithy_schema::ShapeType::String,
  276         -
    "role_name",
         276  +
    "RoleName",
  277    277   
    11,
  278    278   
);
  279    279   
static IMPORTIMAGEINPUT_MEMBER_LICENSE_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  280    280   
    ::aws_smithy_schema::ShapeId::from_static(
  281    281   
        "com.amazonaws.ec2.synthetic#ImportImageInput$LicenseSpecifications",
  282    282   
        "com.amazonaws.ec2.synthetic",
  283    283   
        "ImportImageInput",
  284    284   
    ),
  285    285   
    ::aws_smithy_schema::ShapeType::List,
  286         -
    "license_specifications",
         286  +
    "LicenseSpecifications",
  287    287   
    12,
  288    288   
);
  289    289   
static IMPORTIMAGEINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  290    290   
    ::aws_smithy_schema::ShapeId::from_static(
  291    291   
        "com.amazonaws.ec2.synthetic#ImportImageInput$TagSpecifications",
  292    292   
        "com.amazonaws.ec2.synthetic",
  293    293   
        "ImportImageInput",
  294    294   
    ),
  295    295   
    ::aws_smithy_schema::ShapeType::List,
  296         -
    "tag_specifications",
         296  +
    "TagSpecifications",
  297    297   
    13,
  298    298   
)
  299    299   
.with_xml_name("TagSpecification");
  300    300   
static IMPORTIMAGEINPUT_MEMBER_USAGE_OPERATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  301    301   
    ::aws_smithy_schema::ShapeId::from_static(
  302    302   
        "com.amazonaws.ec2.synthetic#ImportImageInput$UsageOperation",
  303    303   
        "com.amazonaws.ec2.synthetic",
  304    304   
        "ImportImageInput",
  305    305   
    ),
  306    306   
    ::aws_smithy_schema::ShapeType::String,
  307         -
    "usage_operation",
         307  +
    "UsageOperation",
  308    308   
    14,
  309    309   
);
  310    310   
static IMPORTIMAGEINPUT_MEMBER_BOOT_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  311    311   
    ::aws_smithy_schema::ShapeId::from_static(
  312    312   
        "com.amazonaws.ec2.synthetic#ImportImageInput$BootMode",
  313    313   
        "com.amazonaws.ec2.synthetic",
  314    314   
        "ImportImageInput",
  315    315   
    ),
  316    316   
    ::aws_smithy_schema::ShapeType::String,
  317         -
    "boot_mode",
         317  +
    "BootMode",
  318    318   
    15,
  319    319   
);
  320    320   
static IMPORTIMAGEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  321    321   
    IMPORTIMAGEINPUT_SCHEMA_ID,
  322    322   
    ::aws_smithy_schema::ShapeType::Structure,
  323    323   
    &[
  324    324   
        &IMPORTIMAGEINPUT_MEMBER_ARCHITECTURE,
  325    325   
        &IMPORTIMAGEINPUT_MEMBER_CLIENT_DATA,
  326    326   
        &IMPORTIMAGEINPUT_MEMBER_CLIENT_TOKEN,
  327    327   
        &IMPORTIMAGEINPUT_MEMBER_DESCRIPTION,
@@ -399,399 +559,561 @@
  419    419   
            ser.write_string(&IMPORTIMAGEINPUT_MEMBER_USAGE_OPERATION, val)?;
  420    420   
        }
  421    421   
        if let Some(ref val) = self.boot_mode {
  422    422   
            ser.write_string(&IMPORTIMAGEINPUT_MEMBER_BOOT_MODE, val.as_str())?;
  423    423   
        }
  424    424   
        Ok(())
  425    425   
    }
  426    426   
}
  427    427   
impl ImportImageInput {
  428    428   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  429         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  430         -
        deserializer: &mut D,
         429  +
    pub fn deserialize(
         430  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  431    431   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  432    432   
        #[allow(unused_variables, unused_mut)]
  433    433   
        let mut builder = Self::builder();
  434    434   
        #[allow(
  435    435   
            unused_variables,
  436    436   
            unreachable_code,
  437    437   
            clippy::single_match,
  438    438   
            clippy::match_single_binding,
  439    439   
            clippy::diverging_sub_expression
  440    440   
        )]
  441         -
        deserializer.read_struct(&IMPORTIMAGEINPUT_SCHEMA, (), |_, member, deser| {
         441  +
        deserializer.read_struct(&IMPORTIMAGEINPUT_SCHEMA, &mut |member, deser| {
  442    442   
            match member.member_index() {
  443    443   
                Some(0) => {
  444    444   
                    builder.architecture = Some(deser.read_string(member)?);
  445    445   
                }
  446    446   
                Some(1) => {
  447    447   
                    builder.client_data = Some(crate::types::ClientData::deserialize(deser)?);
  448    448   
                }
  449    449   
                Some(2) => {
  450    450   
                    builder.client_token = Some(deser.read_string(member)?);
  451    451   
                }
  452    452   
                Some(3) => {
  453    453   
                    builder.description = Some(deser.read_string(member)?);
  454    454   
                }
  455    455   
                Some(4) => {
  456    456   
                    builder.disk_containers = Some({
  457         -
                        let container = if let Some(cap) = deser.container_size() {
  458         -
                            Vec::with_capacity(cap)
  459         -
                        } else {
  460         -
                            Vec::new()
  461         -
                        };
  462         -
                        deser.read_list(member, container, |mut list, deser| {
  463         -
                            list.push(crate::types::ImageDiskContainer::deserialize(deser)?);
  464         -
                            Ok(list)
  465         -
                        })?
         457  +
                        let mut container = Vec::new();
         458  +
                        deser.read_list(member, &mut |deser| {
         459  +
                            container.push(crate::types::ImageDiskContainer::deserialize(deser)?);
         460  +
                            Ok(())
         461  +
                        })?;
         462  +
                        container
  466    463   
                    });
  467    464   
                }
  468    465   
                Some(5) => {
  469    466   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  470    467   
                }
  471    468   
                Some(6) => {
  472    469   
                    builder.encrypted = Some(deser.read_boolean(member)?);
  473    470   
                }
  474    471   
                Some(7) => {
  475    472   
                    builder.hypervisor = Some(deser.read_string(member)?);
  476    473   
                }
  477    474   
                Some(8) => {
  478    475   
                    builder.kms_key_id = Some(deser.read_string(member)?);
  479    476   
                }
  480    477   
                Some(9) => {
  481    478   
                    builder.license_type = Some(deser.read_string(member)?);
  482    479   
                }
  483    480   
                Some(10) => {
  484    481   
                    builder.platform = Some(deser.read_string(member)?);
  485    482   
                }
  486    483   
                Some(11) => {
  487    484   
                    builder.role_name = Some(deser.read_string(member)?);
  488    485   
                }
  489    486   
                Some(12) => {
  490    487   
                    builder.license_specifications = Some({
  491         -
                        let container = if let Some(cap) = deser.container_size() {
  492         -
                            Vec::with_capacity(cap)
  493         -
                        } else {
  494         -
                            Vec::new()
  495         -
                        };
  496         -
                        deser.read_list(member, container, |mut list, deser| {
  497         -
                            list.push(crate::types::ImportImageLicenseConfigurationRequest::deserialize(deser)?);
  498         -
                            Ok(list)
  499         -
                        })?
         488  +
                        let mut container = Vec::new();
         489  +
                        deser.read_list(member, &mut |deser| {
         490  +
                            container.push(crate::types::ImportImageLicenseConfigurationRequest::deserialize(deser)?);
         491  +
                            Ok(())
         492  +
                        })?;
         493  +
                        container
  500    494   
                    });
  501    495   
                }
  502    496   
                Some(13) => {
  503    497   
                    builder.tag_specifications = Some({
  504         -
                        let container = if let Some(cap) = deser.container_size() {
  505         -
                            Vec::with_capacity(cap)
  506         -
                        } else {
  507         -
                            Vec::new()
  508         -
                        };
  509         -
                        deser.read_list(member, container, |mut list, deser| {
  510         -
                            list.push(crate::types::TagSpecification::deserialize(deser)?);
  511         -
                            Ok(list)
  512         -
                        })?
         498  +
                        let mut container = Vec::new();
         499  +
                        deser.read_list(member, &mut |deser| {
         500  +
                            container.push(crate::types::TagSpecification::deserialize(deser)?);
         501  +
                            Ok(())
         502  +
                        })?;
         503  +
                        container
  513    504   
                    });
  514    505   
                }
  515    506   
                Some(14) => {
  516    507   
                    builder.usage_operation = Some(deser.read_string(member)?);
  517    508   
                }
  518    509   
                Some(15) => {
  519    510   
                    builder.boot_mode = Some(crate::types::BootModeValues::from(deser.read_string(member)?.as_str()));
  520    511   
                }
  521    512   
                _ => {}
  522    513   
            }
  523    514   
            Ok(())
  524    515   
        })?;
  525    516   
        builder
  526    517   
            .build()
  527    518   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  528    519   
    }
  529    520   
}
         521  +
impl ImportImageInput {
         522  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         523  +
    pub fn deserialize_with_response(
         524  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         525  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         526  +
        _status: u16,
         527  +
        _body: &[u8],
         528  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         529  +
        Self::deserialize(deserializer)
         530  +
    }
         531  +
}
  530    532   
impl ImportImageInput {
  531    533   
    /// Creates a new builder-style object to manufacture [`ImportImageInput`](crate::operation::import_image::ImportImageInput).
  532    534   
    pub fn builder() -> crate::operation::import_image::builders::ImportImageInputBuilder {
  533    535   
        crate::operation::import_image::builders::ImportImageInputBuilder::default()
  534    536   
    }
  535    537   
}
  536    538   
  537    539   
/// A builder for [`ImportImageInput`](crate::operation::import_image::ImportImageInput).
  538    540   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  539    541   
#[non_exhaustive]

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

@@ -94,94 +342,350 @@
  114    114   
    "com.amazonaws.ec2.synthetic",
  115    115   
    "ImportImageOutput",
  116    116   
);
  117    117   
static IMPORTIMAGEOUTPUT_MEMBER_ARCHITECTURE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$Architecture",
  120    120   
        "com.amazonaws.ec2.synthetic",
  121    121   
        "ImportImageOutput",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::String,
  124         -
    "architecture",
         124  +
    "Architecture",
  125    125   
    0,
  126    126   
)
  127    127   
.with_xml_name("architecture");
  128    128   
static IMPORTIMAGEOUTPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static(
  130    130   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$Description",
  131    131   
        "com.amazonaws.ec2.synthetic",
  132    132   
        "ImportImageOutput",
  133    133   
    ),
  134    134   
    ::aws_smithy_schema::ShapeType::String,
  135         -
    "description",
         135  +
    "Description",
  136    136   
    1,
  137    137   
)
  138    138   
.with_xml_name("description");
  139    139   
static IMPORTIMAGEOUTPUT_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static(
  141    141   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$Encrypted",
  142    142   
        "com.amazonaws.ec2.synthetic",
  143    143   
        "ImportImageOutput",
  144    144   
    ),
  145    145   
    ::aws_smithy_schema::ShapeType::Boolean,
  146         -
    "encrypted",
         146  +
    "Encrypted",
  147    147   
    2,
  148    148   
)
  149    149   
.with_xml_name("encrypted");
  150    150   
static IMPORTIMAGEOUTPUT_MEMBER_HYPERVISOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  151    151   
    ::aws_smithy_schema::ShapeId::from_static(
  152    152   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$Hypervisor",
  153    153   
        "com.amazonaws.ec2.synthetic",
  154    154   
        "ImportImageOutput",
  155    155   
    ),
  156    156   
    ::aws_smithy_schema::ShapeType::String,
  157         -
    "hypervisor",
         157  +
    "Hypervisor",
  158    158   
    3,
  159    159   
)
  160    160   
.with_xml_name("hypervisor");
  161    161   
static IMPORTIMAGEOUTPUT_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  162    162   
    ::aws_smithy_schema::ShapeId::from_static(
  163    163   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$ImageId",
  164    164   
        "com.amazonaws.ec2.synthetic",
  165    165   
        "ImportImageOutput",
  166    166   
    ),
  167    167   
    ::aws_smithy_schema::ShapeType::String,
  168         -
    "image_id",
         168  +
    "ImageId",
  169    169   
    4,
  170    170   
)
  171    171   
.with_xml_name("imageId");
  172    172   
static IMPORTIMAGEOUTPUT_MEMBER_IMPORT_TASK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  173    173   
    ::aws_smithy_schema::ShapeId::from_static(
  174    174   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$ImportTaskId",
  175    175   
        "com.amazonaws.ec2.synthetic",
  176    176   
        "ImportImageOutput",
  177    177   
    ),
  178    178   
    ::aws_smithy_schema::ShapeType::String,
  179         -
    "import_task_id",
         179  +
    "ImportTaskId",
  180    180   
    5,
  181    181   
)
  182    182   
.with_xml_name("importTaskId");
  183    183   
static IMPORTIMAGEOUTPUT_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  184    184   
    ::aws_smithy_schema::ShapeId::from_static(
  185    185   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$KmsKeyId",
  186    186   
        "com.amazonaws.ec2.synthetic",
  187    187   
        "ImportImageOutput",
  188    188   
    ),
  189    189   
    ::aws_smithy_schema::ShapeType::String,
  190         -
    "kms_key_id",
         190  +
    "KmsKeyId",
  191    191   
    6,
  192    192   
)
  193    193   
.with_xml_name("kmsKeyId");
  194    194   
static IMPORTIMAGEOUTPUT_MEMBER_LICENSE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  195    195   
    ::aws_smithy_schema::ShapeId::from_static(
  196    196   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$LicenseType",
  197    197   
        "com.amazonaws.ec2.synthetic",
  198    198   
        "ImportImageOutput",
  199    199   
    ),
  200    200   
    ::aws_smithy_schema::ShapeType::String,
  201         -
    "license_type",
         201  +
    "LicenseType",
  202    202   
    7,
  203    203   
)
  204    204   
.with_xml_name("licenseType");
  205    205   
static IMPORTIMAGEOUTPUT_MEMBER_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  206    206   
    ::aws_smithy_schema::ShapeId::from_static(
  207    207   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$Platform",
  208    208   
        "com.amazonaws.ec2.synthetic",
  209    209   
        "ImportImageOutput",
  210    210   
    ),
  211    211   
    ::aws_smithy_schema::ShapeType::String,
  212         -
    "platform",
         212  +
    "Platform",
  213    213   
    8,
  214    214   
)
  215    215   
.with_xml_name("platform");
  216    216   
static IMPORTIMAGEOUTPUT_MEMBER_PROGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  217    217   
    ::aws_smithy_schema::ShapeId::from_static(
  218    218   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$Progress",
  219    219   
        "com.amazonaws.ec2.synthetic",
  220    220   
        "ImportImageOutput",
  221    221   
    ),
  222    222   
    ::aws_smithy_schema::ShapeType::String,
  223         -
    "progress",
         223  +
    "Progress",
  224    224   
    9,
  225    225   
)
  226    226   
.with_xml_name("progress");
  227    227   
static IMPORTIMAGEOUTPUT_MEMBER_SNAPSHOT_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  228    228   
    ::aws_smithy_schema::ShapeId::from_static(
  229    229   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$SnapshotDetails",
  230    230   
        "com.amazonaws.ec2.synthetic",
  231    231   
        "ImportImageOutput",
  232    232   
    ),
  233    233   
    ::aws_smithy_schema::ShapeType::List,
  234         -
    "snapshot_details",
         234  +
    "SnapshotDetails",
  235    235   
    10,
  236    236   
)
  237    237   
.with_xml_name("snapshotDetailSet");
  238    238   
static IMPORTIMAGEOUTPUT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  239    239   
    ::aws_smithy_schema::ShapeId::from_static(
  240    240   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$Status",
  241    241   
        "com.amazonaws.ec2.synthetic",
  242    242   
        "ImportImageOutput",
  243    243   
    ),
  244    244   
    ::aws_smithy_schema::ShapeType::String,
  245         -
    "status",
         245  +
    "Status",
  246    246   
    11,
  247    247   
)
  248    248   
.with_xml_name("status");
  249    249   
static IMPORTIMAGEOUTPUT_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  250    250   
    ::aws_smithy_schema::ShapeId::from_static(
  251    251   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$StatusMessage",
  252    252   
        "com.amazonaws.ec2.synthetic",
  253    253   
        "ImportImageOutput",
  254    254   
    ),
  255    255   
    ::aws_smithy_schema::ShapeType::String,
  256         -
    "status_message",
         256  +
    "StatusMessage",
  257    257   
    12,
  258    258   
)
  259    259   
.with_xml_name("statusMessage");
  260    260   
static IMPORTIMAGEOUTPUT_MEMBER_LICENSE_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  261    261   
    ::aws_smithy_schema::ShapeId::from_static(
  262    262   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$LicenseSpecifications",
  263    263   
        "com.amazonaws.ec2.synthetic",
  264    264   
        "ImportImageOutput",
  265    265   
    ),
  266    266   
    ::aws_smithy_schema::ShapeType::List,
  267         -
    "license_specifications",
         267  +
    "LicenseSpecifications",
  268    268   
    13,
  269    269   
)
  270    270   
.with_xml_name("licenseSpecifications");
  271    271   
static IMPORTIMAGEOUTPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  272    272   
    ::aws_smithy_schema::ShapeId::from_static(
  273    273   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$Tags",
  274    274   
        "com.amazonaws.ec2.synthetic",
  275    275   
        "ImportImageOutput",
  276    276   
    ),
  277    277   
    ::aws_smithy_schema::ShapeType::List,
  278         -
    "tags",
         278  +
    "Tags",
  279    279   
    14,
  280    280   
)
  281    281   
.with_xml_name("tagSet");
  282    282   
static IMPORTIMAGEOUTPUT_MEMBER_USAGE_OPERATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  283    283   
    ::aws_smithy_schema::ShapeId::from_static(
  284    284   
        "com.amazonaws.ec2.synthetic#ImportImageOutput$UsageOperation",
  285    285   
        "com.amazonaws.ec2.synthetic",
  286    286   
        "ImportImageOutput",
  287    287   
    ),
  288    288   
    ::aws_smithy_schema::ShapeType::String,
  289         -
    "usage_operation",
         289  +
    "UsageOperation",
  290    290   
    15,
  291    291   
)
  292    292   
.with_xml_name("usageOperation");
         293  +
static IMPORTIMAGEOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         294  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         295  +
    ::aws_smithy_schema::ShapeType::String,
         296  +
    "request_id",
         297  +
    16,
         298  +
)
         299  +
.with_http_header("x-amzn-requestid");
  293    300   
static IMPORTIMAGEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  294    301   
    IMPORTIMAGEOUTPUT_SCHEMA_ID,
  295    302   
    ::aws_smithy_schema::ShapeType::Structure,
  296    303   
    &[
  297    304   
        &IMPORTIMAGEOUTPUT_MEMBER_ARCHITECTURE,
  298    305   
        &IMPORTIMAGEOUTPUT_MEMBER_DESCRIPTION,
  299    306   
        &IMPORTIMAGEOUTPUT_MEMBER_ENCRYPTED,
  300    307   
        &IMPORTIMAGEOUTPUT_MEMBER_HYPERVISOR,
  301    308   
        &IMPORTIMAGEOUTPUT_MEMBER_IMAGE_ID,
  302    309   
        &IMPORTIMAGEOUTPUT_MEMBER_IMPORT_TASK_ID,
  303    310   
        &IMPORTIMAGEOUTPUT_MEMBER_KMS_KEY_ID,
  304    311   
        &IMPORTIMAGEOUTPUT_MEMBER_LICENSE_TYPE,
  305    312   
        &IMPORTIMAGEOUTPUT_MEMBER_PLATFORM,
  306    313   
        &IMPORTIMAGEOUTPUT_MEMBER_PROGRESS,
  307    314   
        &IMPORTIMAGEOUTPUT_MEMBER_SNAPSHOT_DETAILS,
  308    315   
        &IMPORTIMAGEOUTPUT_MEMBER_STATUS,
  309    316   
        &IMPORTIMAGEOUTPUT_MEMBER_STATUS_MESSAGE,
  310    317   
        &IMPORTIMAGEOUTPUT_MEMBER_LICENSE_SPECIFICATIONS,
  311    318   
        &IMPORTIMAGEOUTPUT_MEMBER_TAGS,
  312    319   
        &IMPORTIMAGEOUTPUT_MEMBER_USAGE_OPERATION,
         320  +
        &IMPORTIMAGEOUTPUT_MEMBER__REQUEST_ID,
  313    321   
    ],
  314    322   
);
  315    323   
impl ImportImageOutput {
  316    324   
    /// The schema for this shape.
  317    325   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IMPORTIMAGEOUTPUT_SCHEMA;
  318    326   
}
  319    327   
impl ::aws_smithy_schema::serde::SerializableStruct for ImportImageOutput {
  320    328   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  321    329   
    fn serialize_members(
  322    330   
        &self,
@@ -372,380 +518,620 @@
  392    400   
            )?;
  393    401   
        }
  394    402   
        if let Some(ref val) = self.usage_operation {
  395    403   
            ser.write_string(&IMPORTIMAGEOUTPUT_MEMBER_USAGE_OPERATION, val)?;
  396    404   
        }
  397    405   
        Ok(())
  398    406   
    }
  399    407   
}
  400    408   
impl ImportImageOutput {
  401    409   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  402         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  403         -
        deserializer: &mut D,
         410  +
    pub fn deserialize(
         411  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         412  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         413  +
        #[allow(unused_variables, unused_mut)]
         414  +
        let mut builder = Self::builder();
         415  +
        #[allow(
         416  +
            unused_variables,
         417  +
            unreachable_code,
         418  +
            clippy::single_match,
         419  +
            clippy::match_single_binding,
         420  +
            clippy::diverging_sub_expression
         421  +
        )]
         422  +
        deserializer.read_struct(&IMPORTIMAGEOUTPUT_SCHEMA, &mut |member, deser| {
         423  +
            match member.member_index() {
         424  +
                Some(0) => {
         425  +
                    builder.architecture = Some(deser.read_string(member)?);
         426  +
                }
         427  +
                Some(1) => {
         428  +
                    builder.description = Some(deser.read_string(member)?);
         429  +
                }
         430  +
                Some(2) => {
         431  +
                    builder.encrypted = Some(deser.read_boolean(member)?);
         432  +
                }
         433  +
                Some(3) => {
         434  +
                    builder.hypervisor = Some(deser.read_string(member)?);
         435  +
                }
         436  +
                Some(4) => {
         437  +
                    builder.image_id = Some(deser.read_string(member)?);
         438  +
                }
         439  +
                Some(5) => {
         440  +
                    builder.import_task_id = Some(deser.read_string(member)?);
         441  +
                }
         442  +
                Some(6) => {
         443  +
                    builder.kms_key_id = Some(deser.read_string(member)?);
         444  +
                }
         445  +
                Some(7) => {
         446  +
                    builder.license_type = Some(deser.read_string(member)?);
         447  +
                }
         448  +
                Some(8) => {
         449  +
                    builder.platform = Some(deser.read_string(member)?);
         450  +
                }
         451  +
                Some(9) => {
         452  +
                    builder.progress = Some(deser.read_string(member)?);
         453  +
                }
         454  +
                Some(10) => {
         455  +
                    builder.snapshot_details = Some({
         456  +
                        let mut container = Vec::new();
         457  +
                        deser.read_list(member, &mut |deser| {
         458  +
                            container.push(crate::types::SnapshotDetail::deserialize(deser)?);
         459  +
                            Ok(())
         460  +
                        })?;
         461  +
                        container
         462  +
                    });
         463  +
                }
         464  +
                Some(11) => {
         465  +
                    builder.status = Some(deser.read_string(member)?);
         466  +
                }
         467  +
                Some(12) => {
         468  +
                    builder.status_message = Some(deser.read_string(member)?);
         469  +
                }
         470  +
                Some(13) => {
         471  +
                    builder.license_specifications = Some({
         472  +
                        let mut container = Vec::new();
         473  +
                        deser.read_list(member, &mut |deser| {
         474  +
                            container.push(crate::types::ImportImageLicenseConfigurationResponse::deserialize(deser)?);
         475  +
                            Ok(())
         476  +
                        })?;
         477  +
                        container
         478  +
                    });
         479  +
                }
         480  +
                Some(14) => {
         481  +
                    builder.tags = Some({
         482  +
                        let mut container = Vec::new();
         483  +
                        deser.read_list(member, &mut |deser| {
         484  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         485  +
                            Ok(())
         486  +
                        })?;
         487  +
                        container
         488  +
                    });
         489  +
                }
         490  +
                Some(15) => {
         491  +
                    builder.usage_operation = Some(deser.read_string(member)?);
         492  +
                }
         493  +
                Some(16) => {
         494  +
                    builder._request_id = Some(deser.read_string(member)?);
         495  +
                }
         496  +
                _ => {}
         497  +
            }
         498  +
            Ok(())
         499  +
        })?;
         500  +
        Ok(builder.build())
         501  +
    }
         502  +
}
         503  +
impl ImportImageOutput {
         504  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         505  +
    /// Header-bound members are read directly from headers, avoiding runtime
         506  +
    /// member iteration overhead. Body members are read via the deserializer.
         507  +
    pub fn deserialize_with_response(
         508  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         509  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         510  +
        _status: u16,
         511  +
        _body: &[u8],
  404    512   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  405    513   
        #[allow(unused_variables, unused_mut)]
  406    514   
        let mut builder = Self::builder();
         515  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         516  +
            builder._request_id = Some(val.to_string());
         517  +
        }
  407    518   
        #[allow(
  408    519   
            unused_variables,
  409    520   
            unreachable_code,
  410    521   
            clippy::single_match,
  411    522   
            clippy::match_single_binding,
  412    523   
            clippy::diverging_sub_expression
  413    524   
        )]
  414         -
        deserializer.read_struct(&IMPORTIMAGEOUTPUT_SCHEMA, (), |_, member, deser| {
         525  +
        deserializer.read_struct(&IMPORTIMAGEOUTPUT_SCHEMA, &mut |member, deser| {
  415    526   
            match member.member_index() {
  416    527   
                Some(0) => {
  417    528   
                    builder.architecture = Some(deser.read_string(member)?);
  418    529   
                }
  419    530   
                Some(1) => {
  420    531   
                    builder.description = Some(deser.read_string(member)?);
  421    532   
                }
  422    533   
                Some(2) => {
  423    534   
                    builder.encrypted = Some(deser.read_boolean(member)?);
  424    535   
                }
  425    536   
                Some(3) => {
  426    537   
                    builder.hypervisor = Some(deser.read_string(member)?);
  427    538   
                }
  428    539   
                Some(4) => {
  429    540   
                    builder.image_id = Some(deser.read_string(member)?);
  430    541   
                }
  431    542   
                Some(5) => {
  432    543   
                    builder.import_task_id = Some(deser.read_string(member)?);
  433    544   
                }
  434    545   
                Some(6) => {
  435    546   
                    builder.kms_key_id = Some(deser.read_string(member)?);
  436    547   
                }
  437    548   
                Some(7) => {
  438    549   
                    builder.license_type = Some(deser.read_string(member)?);
  439    550   
                }
  440    551   
                Some(8) => {
  441    552   
                    builder.platform = Some(deser.read_string(member)?);
  442    553   
                }
  443    554   
                Some(9) => {
  444    555   
                    builder.progress = Some(deser.read_string(member)?);
  445    556   
                }
  446    557   
                Some(10) => {
  447    558   
                    builder.snapshot_details = Some({
  448         -
                        let container = if let Some(cap) = deser.container_size() {
  449         -
                            Vec::with_capacity(cap)
  450         -
                        } else {
  451         -
                            Vec::new()
  452         -
                        };
  453         -
                        deser.read_list(member, container, |mut list, deser| {
  454         -
                            list.push(crate::types::SnapshotDetail::deserialize(deser)?);
  455         -
                            Ok(list)
  456         -
                        })?
         559  +
                        let mut container = Vec::new();
         560  +
                        deser.read_list(member, &mut |deser| {
         561  +
                            container.push(crate::types::SnapshotDetail::deserialize(deser)?);
         562  +
                            Ok(())
         563  +
                        })?;
         564  +
                        container
  457    565   
                    });
  458    566   
                }
  459    567   
                Some(11) => {
  460    568   
                    builder.status = Some(deser.read_string(member)?);
  461    569   
                }
  462    570   
                Some(12) => {
  463    571   
                    builder.status_message = Some(deser.read_string(member)?);
  464    572   
                }
  465    573   
                Some(13) => {
  466    574   
                    builder.license_specifications = Some({
  467         -
                        let container = if let Some(cap) = deser.container_size() {
  468         -
                            Vec::with_capacity(cap)
  469         -
                        } else {
  470         -
                            Vec::new()
  471         -
                        };
  472         -
                        deser.read_list(member, container, |mut list, deser| {
  473         -
                            list.push(crate::types::ImportImageLicenseConfigurationResponse::deserialize(deser)?);
  474         -
                            Ok(list)
  475         -
                        })?
         575  +
                        let mut container = Vec::new();
         576  +
                        deser.read_list(member, &mut |deser| {
         577  +
                            container.push(crate::types::ImportImageLicenseConfigurationResponse::deserialize(deser)?);
         578  +
                            Ok(())
         579  +
                        })?;
         580  +
                        container
  476    581   
                    });
  477    582   
                }
  478    583   
                Some(14) => {
  479    584   
                    builder.tags = Some({
  480         -
                        let container = if let Some(cap) = deser.container_size() {
  481         -
                            Vec::with_capacity(cap)
  482         -
                        } else {
  483         -
                            Vec::new()
  484         -
                        };
  485         -
                        deser.read_list(member, container, |mut list, deser| {
  486         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  487         -
                            Ok(list)
  488         -
                        })?
         585  +
                        let mut container = Vec::new();
         586  +
                        deser.read_list(member, &mut |deser| {
         587  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         588  +
                            Ok(())
         589  +
                        })?;
         590  +
                        container
  489    591   
                    });
  490    592   
                }
  491    593   
                Some(15) => {
  492    594   
                    builder.usage_operation = Some(deser.read_string(member)?);
  493    595   
                }
  494    596   
                _ => {}
  495    597   
            }
  496    598   
            Ok(())
  497    599   
        })?;
  498    600   
        Ok(builder.build())

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/import_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 `ImportInstance`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ImportInstance;
    6      6   
impl ImportInstance {
    7      7   
    /// Creates a new `ImportInstance`
    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::import_instance::ImportInstanceInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::import_instance::ImportInstanceOutput::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::import_instance::ImportInstanceInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::import_instance::ImportInstanceOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::import_instance::ImportInstanceError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -116,120 +178,183 @@
  136    140   
                crate::operation::import_instance::ImportInstanceError,
  137    141   
            >::new());
  138    142   
  139    143   
        ::std::borrow::Cow::Owned(rcb)
  140    144   
    }
  141    145   
}
  142    146   
  143    147   
#[derive(Debug)]
  144    148   
struct ImportInstanceResponseDeserializer;
  145    149   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ImportInstanceResponseDeserializer {
  146         -
    fn deserialize_nonstreaming(
         150  +
    fn deserialize_nonstreaming_with_config(
  147    151   
        &self,
  148    152   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         153  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  149    154   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  150    155   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  151    156   
        let headers = response.headers();
  152    157   
        let body = response.body().bytes().expect("body loaded");
  153    158   
        #[allow(unused_mut)]
  154    159   
        let mut force_error = false;
  155    160   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  156    161   
        let parse_result = if !success && status != 200 || force_error {
  157    162   
            crate::protocol_serde::shape_import_instance::de_import_instance_http_error(status, headers, body)
  158    163   
        } else {

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

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

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

@@ -1,1 +97,141 @@
   18     18   
    "com.amazonaws.ec2.synthetic",
   19     19   
    "ImportInstanceOutput",
   20     20   
);
   21     21   
static IMPORTINSTANCEOUTPUT_MEMBER_CONVERSION_TASK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.ec2.synthetic#ImportInstanceOutput$ConversionTask",
   24     24   
        "com.amazonaws.ec2.synthetic",
   25     25   
        "ImportInstanceOutput",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28         -
    "conversion_task",
          28  +
    "ConversionTask",
   29     29   
    0,
   30     30   
)
   31     31   
.with_xml_name("conversionTask");
          32  +
static IMPORTINSTANCEOUTPUT_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 IMPORTINSTANCEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     40   
    IMPORTINSTANCEOUTPUT_SCHEMA_ID,
   34     41   
    ::aws_smithy_schema::ShapeType::Structure,
   35         -
    &[&IMPORTINSTANCEOUTPUT_MEMBER_CONVERSION_TASK],
          42  +
    &[&IMPORTINSTANCEOUTPUT_MEMBER_CONVERSION_TASK, &IMPORTINSTANCEOUTPUT_MEMBER__REQUEST_ID],
   36     43   
);
   37     44   
impl ImportInstanceOutput {
   38     45   
    /// The schema for this shape.
   39     46   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IMPORTINSTANCEOUTPUT_SCHEMA;
   40     47   
}
   41     48   
impl ::aws_smithy_schema::serde::SerializableStruct for ImportInstanceOutput {
   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.conversion_task {
   48     55   
            ser.write_struct(&IMPORTINSTANCEOUTPUT_MEMBER_CONVERSION_TASK, val)?;
   49     56   
        }
   50     57   
        Ok(())
   51     58   
    }
   52     59   
}
   53     60   
impl ImportInstanceOutput {
   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,
   57     64   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   58     65   
        #[allow(unused_variables, unused_mut)]
   59     66   
        let mut builder = Self::builder();
   60     67   
        #[allow(
   61     68   
            unused_variables,
   62     69   
            unreachable_code,
   63     70   
            clippy::single_match,
   64     71   
            clippy::match_single_binding,
   65     72   
            clippy::diverging_sub_expression
   66     73   
        )]
   67         -
        deserializer.read_struct(&IMPORTINSTANCEOUTPUT_SCHEMA, (), |_, member, deser| {
          74  +
        deserializer.read_struct(&IMPORTINSTANCEOUTPUT_SCHEMA, &mut |member, deser| {
          75  +
            match member.member_index() {
          76  +
                Some(0) => {
          77  +
                    builder.conversion_task = Some(crate::types::ConversionTask::deserialize(deser)?);
          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 ImportInstanceOutput {
          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],
          98  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          99  +
        #[allow(unused_variables, unused_mut)]
         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  +
        }
         104  +
        #[allow(
         105  +
            unused_variables,
         106  +
            unreachable_code,
         107  +
            clippy::single_match,
         108  +
            clippy::match_single_binding,
         109  +
            clippy::diverging_sub_expression
         110  +
        )]
         111  +
        deserializer.read_struct(&IMPORTINSTANCEOUTPUT_SCHEMA, &mut |member, deser| {
   68    112   
            match member.member_index() {
   69    113   
                Some(0) => {
   70    114   
                    builder.conversion_task = Some(crate::types::ConversionTask::deserialize(deser)?);
   71    115   
                }
   72    116   
                _ => {}
   73    117   
            }
   74    118   
            Ok(())
   75    119   
        })?;
   76    120   
        Ok(builder.build())
   77    121   
    }

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/import_key_pair.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 `ImportKeyPair`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ImportKeyPair;
    6      6   
impl ImportKeyPair {
    7      7   
    /// Creates a new `ImportKeyPair`
    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::import_key_pair::ImportKeyPairInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::import_key_pair::ImportKeyPairOutput::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::import_key_pair::ImportKeyPairInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::import_key_pair::ImportKeyPairOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::import_key_pair::ImportKeyPairError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -115,119 +177,182 @@
  135    139   
                crate::operation::import_key_pair::ImportKeyPairError,
  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 ImportKeyPairResponseDeserializer;
  144    148   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ImportKeyPairResponseDeserializer {
  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_import_key_pair::de_import_key_pair_http_error(status, headers, body)
  157    162   
        } else {

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

@@ -17,17 +203,213 @@
   37     37   
    "com.amazonaws.ec2.synthetic",
   38     38   
    "ImportKeyPairInput",
   39     39   
);
   40     40   
static IMPORTKEYPAIRINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.ec2.synthetic#ImportKeyPairInput$TagSpecifications",
   43     43   
        "com.amazonaws.ec2.synthetic",
   44     44   
        "ImportKeyPairInput",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::List,
   47         -
    "tag_specifications",
          47  +
    "TagSpecifications",
   48     48   
    0,
   49     49   
)
   50     50   
.with_xml_name("TagSpecification");
   51     51   
static IMPORTKEYPAIRINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.ec2.synthetic#ImportKeyPairInput$DryRun",
   54     54   
        "com.amazonaws.ec2.synthetic",
   55     55   
        "ImportKeyPairInput",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::Boolean,
   58         -
    "dry_run",
          58  +
    "DryRun",
   59     59   
    1,
   60     60   
)
   61     61   
.with_xml_name("dryRun");
   62     62   
static IMPORTKEYPAIRINPUT_MEMBER_KEY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.ec2.synthetic#ImportKeyPairInput$KeyName",
   65     65   
        "com.amazonaws.ec2.synthetic",
   66     66   
        "ImportKeyPairInput",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "key_name",
          69  +
    "KeyName",
   70     70   
    2,
   71     71   
)
   72     72   
.with_xml_name("keyName");
   73     73   
static IMPORTKEYPAIRINPUT_MEMBER_PUBLIC_KEY_MATERIAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.ec2.synthetic#ImportKeyPairInput$PublicKeyMaterial",
   76     76   
        "com.amazonaws.ec2.synthetic",
   77     77   
        "ImportKeyPairInput",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::Blob,
   80         -
    "public_key_material",
          80  +
    "PublicKeyMaterial",
   81     81   
    3,
   82     82   
)
   83     83   
.with_xml_name("publicKeyMaterial");
   84     84   
static IMPORTKEYPAIRINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   85     85   
    IMPORTKEYPAIRINPUT_SCHEMA_ID,
   86     86   
    ::aws_smithy_schema::ShapeType::Structure,
   87     87   
    &[
   88     88   
        &IMPORTKEYPAIRINPUT_MEMBER_TAG_SPECIFICATIONS,
   89     89   
        &IMPORTKEYPAIRINPUT_MEMBER_DRY_RUN,
   90     90   
        &IMPORTKEYPAIRINPUT_MEMBER_KEY_NAME,
   91     91   
        &IMPORTKEYPAIRINPUT_MEMBER_PUBLIC_KEY_MATERIAL,
   92     92   
    ],
   93     93   
);
   94     94   
impl ImportKeyPairInput {
   95     95   
    /// The schema for this shape.
   96     96   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IMPORTKEYPAIRINPUT_SCHEMA;
   97     97   
}
   98     98   
impl ::aws_smithy_schema::serde::SerializableStruct for ImportKeyPairInput {
   99     99   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  100    100   
    fn serialize_members(
  101    101   
        &self,
  102    102   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  103    103   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  104    104   
        if let Some(ref val) = self.tag_specifications {
  105    105   
            ser.write_list(
  106    106   
                &IMPORTKEYPAIRINPUT_MEMBER_TAG_SPECIFICATIONS,
  107    107   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  108    108   
                    for item in val {
  109    109   
                        ser.write_struct(crate::types::TagSpecification::SCHEMA, item)?;
  110    110   
                    }
  111    111   
                    Ok(())
  112    112   
                },
  113    113   
            )?;
  114    114   
        }
  115    115   
        if let Some(ref val) = self.dry_run {
  116    116   
            ser.write_boolean(&IMPORTKEYPAIRINPUT_MEMBER_DRY_RUN, *val)?;
  117    117   
        }
  118    118   
        if let Some(ref val) = self.key_name {
  119    119   
            ser.write_string(&IMPORTKEYPAIRINPUT_MEMBER_KEY_NAME, val)?;
  120    120   
        }
  121    121   
        if let Some(ref val) = self.public_key_material {
  122    122   
            ser.write_blob(&IMPORTKEYPAIRINPUT_MEMBER_PUBLIC_KEY_MATERIAL, val)?;
  123    123   
        }
  124    124   
        Ok(())
  125    125   
    }
  126    126   
}
  127    127   
impl ImportKeyPairInput {
  128    128   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  129         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  130         -
        deserializer: &mut D,
         129  +
    pub fn deserialize(
         130  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  131    131   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  132    132   
        #[allow(unused_variables, unused_mut)]
  133    133   
        let mut builder = Self::builder();
  134    134   
        #[allow(
  135    135   
            unused_variables,
  136    136   
            unreachable_code,
  137    137   
            clippy::single_match,
  138    138   
            clippy::match_single_binding,
  139    139   
            clippy::diverging_sub_expression
  140    140   
        )]
  141         -
        deserializer.read_struct(&IMPORTKEYPAIRINPUT_SCHEMA, (), |_, member, deser| {
         141  +
        deserializer.read_struct(&IMPORTKEYPAIRINPUT_SCHEMA, &mut |member, deser| {
  142    142   
            match member.member_index() {
  143    143   
                Some(0) => {
  144    144   
                    builder.tag_specifications = Some({
  145         -
                        let container = if let Some(cap) = deser.container_size() {
  146         -
                            Vec::with_capacity(cap)
  147         -
                        } else {
  148         -
                            Vec::new()
  149         -
                        };
  150         -
                        deser.read_list(member, container, |mut list, deser| {
  151         -
                            list.push(crate::types::TagSpecification::deserialize(deser)?);
  152         -
                            Ok(list)
  153         -
                        })?
         145  +
                        let mut container = Vec::new();
         146  +
                        deser.read_list(member, &mut |deser| {
         147  +
                            container.push(crate::types::TagSpecification::deserialize(deser)?);
         148  +
                            Ok(())
         149  +
                        })?;
         150  +
                        container
  154    151   
                    });
  155    152   
                }
  156    153   
                Some(1) => {
  157    154   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  158    155   
                }
  159    156   
                Some(2) => {
  160    157   
                    builder.key_name = Some(deser.read_string(member)?);
  161    158   
                }
  162    159   
                Some(3) => {
  163    160   
                    builder.public_key_material = Some(deser.read_blob(member)?);
  164    161   
                }
  165    162   
                _ => {}
  166    163   
            }
  167    164   
            Ok(())
  168    165   
        })?;
         166  +
        builder.key_name = builder.key_name.or(Some(String::new()));
         167  +
        builder.public_key_material = builder.public_key_material.or(Some(::aws_smithy_types::Blob::new("")));
  169    168   
        builder
  170    169   
            .build()
  171    170   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  172    171   
    }
  173    172   
}
         173  +
impl ImportKeyPairInput {
         174  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         175  +
    pub fn deserialize_with_response(
         176  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         177  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         178  +
        _status: u16,
         179  +
        _body: &[u8],
         180  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         181  +
        Self::deserialize(deserializer)
         182  +
    }
         183  +
}
  174    184   
impl ImportKeyPairInput {
  175    185   
    /// Creates a new builder-style object to manufacture [`ImportKeyPairInput`](crate::operation::import_key_pair::ImportKeyPairInput).
  176    186   
    pub fn builder() -> crate::operation::import_key_pair::builders::ImportKeyPairInputBuilder {
  177    187   
        crate::operation::import_key_pair::builders::ImportKeyPairInputBuilder::default()
  178    188   
    }
  179    189   
}
  180    190   
  181    191   
/// A builder for [`ImportKeyPairInput`](crate::operation::import_key_pair::ImportKeyPairInput).
  182    192   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  183    193   
#[non_exhaustive]

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

@@ -28,28 +203,261 @@
   48     48   
    "com.amazonaws.ec2.synthetic",
   49     49   
    "ImportKeyPairOutput",
   50     50   
);
   51     51   
static IMPORTKEYPAIROUTPUT_MEMBER_KEY_FINGERPRINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.ec2.synthetic#ImportKeyPairOutput$KeyFingerprint",
   54     54   
        "com.amazonaws.ec2.synthetic",
   55     55   
        "ImportKeyPairOutput",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::String,
   58         -
    "key_fingerprint",
          58  +
    "KeyFingerprint",
   59     59   
    0,
   60     60   
)
   61     61   
.with_xml_name("keyFingerprint");
   62     62   
static IMPORTKEYPAIROUTPUT_MEMBER_KEY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.ec2.synthetic#ImportKeyPairOutput$KeyName",
   65     65   
        "com.amazonaws.ec2.synthetic",
   66     66   
        "ImportKeyPairOutput",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "key_name",
          69  +
    "KeyName",
   70     70   
    1,
   71     71   
)
   72     72   
.with_xml_name("keyName");
   73     73   
static IMPORTKEYPAIROUTPUT_MEMBER_KEY_PAIR_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.ec2.synthetic#ImportKeyPairOutput$KeyPairId",
   76     76   
        "com.amazonaws.ec2.synthetic",
   77     77   
        "ImportKeyPairOutput",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "key_pair_id",
          80  +
    "KeyPairId",
   81     81   
    2,
   82     82   
)
   83     83   
.with_xml_name("keyPairId");
   84     84   
static IMPORTKEYPAIROUTPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "com.amazonaws.ec2.synthetic#ImportKeyPairOutput$Tags",
   87     87   
        "com.amazonaws.ec2.synthetic",
   88     88   
        "ImportKeyPairOutput",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::List,
   91         -
    "tags",
          91  +
    "Tags",
   92     92   
    3,
   93     93   
)
   94     94   
.with_xml_name("tagSet");
          95  +
static IMPORTKEYPAIROUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          96  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          97  +
    ::aws_smithy_schema::ShapeType::String,
          98  +
    "request_id",
          99  +
    4,
         100  +
)
         101  +
.with_http_header("x-amzn-requestid");
   95    102   
static IMPORTKEYPAIROUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   96    103   
    IMPORTKEYPAIROUTPUT_SCHEMA_ID,
   97    104   
    ::aws_smithy_schema::ShapeType::Structure,
   98    105   
    &[
   99    106   
        &IMPORTKEYPAIROUTPUT_MEMBER_KEY_FINGERPRINT,
  100    107   
        &IMPORTKEYPAIROUTPUT_MEMBER_KEY_NAME,
  101    108   
        &IMPORTKEYPAIROUTPUT_MEMBER_KEY_PAIR_ID,
  102    109   
        &IMPORTKEYPAIROUTPUT_MEMBER_TAGS,
         110  +
        &IMPORTKEYPAIROUTPUT_MEMBER__REQUEST_ID,
  103    111   
    ],
  104    112   
);
  105    113   
impl ImportKeyPairOutput {
  106    114   
    /// The schema for this shape.
  107    115   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IMPORTKEYPAIROUTPUT_SCHEMA;
  108    116   
}
  109    117   
impl ::aws_smithy_schema::serde::SerializableStruct for ImportKeyPairOutput {
  110    118   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  111    119   
    fn serialize_members(
  112    120   
        &self,
  113    121   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  114    122   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  115    123   
        if let Some(ref val) = self.key_fingerprint {
  116    124   
            ser.write_string(&IMPORTKEYPAIROUTPUT_MEMBER_KEY_FINGERPRINT, val)?;
  117    125   
        }
  118    126   
        if let Some(ref val) = self.key_name {
  119    127   
            ser.write_string(&IMPORTKEYPAIROUTPUT_MEMBER_KEY_NAME, val)?;
  120    128   
        }
  121    129   
        if let Some(ref val) = self.key_pair_id {
  122    130   
            ser.write_string(&IMPORTKEYPAIROUTPUT_MEMBER_KEY_PAIR_ID, val)?;
  123    131   
        }
  124    132   
        if let Some(ref val) = self.tags {
  125    133   
            ser.write_list(
  126    134   
                &IMPORTKEYPAIROUTPUT_MEMBER_TAGS,
  127    135   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  128    136   
                    for item in val {
  129    137   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  130    138   
                    }
  131    139   
                    Ok(())
  132    140   
                },
  133    141   
            )?;
  134    142   
        }
  135    143   
        Ok(())
  136    144   
    }
  137    145   
}
  138    146   
impl ImportKeyPairOutput {
  139    147   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  140         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  141         -
        deserializer: &mut D,
         148  +
    pub fn deserialize(
         149  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         150  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         151  +
        #[allow(unused_variables, unused_mut)]
         152  +
        let mut builder = Self::builder();
         153  +
        #[allow(
         154  +
            unused_variables,
         155  +
            unreachable_code,
         156  +
            clippy::single_match,
         157  +
            clippy::match_single_binding,
         158  +
            clippy::diverging_sub_expression
         159  +
        )]
         160  +
        deserializer.read_struct(&IMPORTKEYPAIROUTPUT_SCHEMA, &mut |member, deser| {
         161  +
            match member.member_index() {
         162  +
                Some(0) => {
         163  +
                    builder.key_fingerprint = Some(deser.read_string(member)?);
         164  +
                }
         165  +
                Some(1) => {
         166  +
                    builder.key_name = Some(deser.read_string(member)?);
         167  +
                }
         168  +
                Some(2) => {
         169  +
                    builder.key_pair_id = Some(deser.read_string(member)?);
         170  +
                }
         171  +
                Some(3) => {
         172  +
                    builder.tags = Some({
         173  +
                        let mut container = Vec::new();
         174  +
                        deser.read_list(member, &mut |deser| {
         175  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         176  +
                            Ok(())
         177  +
                        })?;
         178  +
                        container
         179  +
                    });
         180  +
                }
         181  +
                Some(4) => {
         182  +
                    builder._request_id = Some(deser.read_string(member)?);
         183  +
                }
         184  +
                _ => {}
         185  +
            }
         186  +
            Ok(())
         187  +
        })?;
         188  +
        Ok(builder.build())
         189  +
    }
         190  +
}
         191  +
impl ImportKeyPairOutput {
         192  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         193  +
    /// Header-bound members are read directly from headers, avoiding runtime
         194  +
    /// member iteration overhead. Body members are read via the deserializer.
         195  +
    pub fn deserialize_with_response(
         196  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         197  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         198  +
        _status: u16,
         199  +
        _body: &[u8],
  142    200   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  143    201   
        #[allow(unused_variables, unused_mut)]
  144    202   
        let mut builder = Self::builder();
         203  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         204  +
            builder._request_id = Some(val.to_string());
         205  +
        }
  145    206   
        #[allow(
  146    207   
            unused_variables,
  147    208   
            unreachable_code,
  148    209   
            clippy::single_match,
  149    210   
            clippy::match_single_binding,
  150    211   
            clippy::diverging_sub_expression
  151    212   
        )]
  152         -
        deserializer.read_struct(&IMPORTKEYPAIROUTPUT_SCHEMA, (), |_, member, deser| {
         213  +
        deserializer.read_struct(&IMPORTKEYPAIROUTPUT_SCHEMA, &mut |member, deser| {
  153    214   
            match member.member_index() {
  154    215   
                Some(0) => {
  155    216   
                    builder.key_fingerprint = Some(deser.read_string(member)?);
  156    217   
                }
  157    218   
                Some(1) => {
  158    219   
                    builder.key_name = Some(deser.read_string(member)?);
  159    220   
                }
  160    221   
                Some(2) => {
  161    222   
                    builder.key_pair_id = Some(deser.read_string(member)?);
  162    223   
                }
  163    224   
                Some(3) => {
  164    225   
                    builder.tags = Some({
  165         -
                        let container = if let Some(cap) = deser.container_size() {
  166         -
                            Vec::with_capacity(cap)
  167         -
                        } else {
  168         -
                            Vec::new()
  169         -
                        };
  170         -
                        deser.read_list(member, container, |mut list, deser| {
  171         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  172         -
                            Ok(list)
  173         -
                        })?
         226  +
                        let mut container = Vec::new();
         227  +
                        deser.read_list(member, &mut |deser| {
         228  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         229  +
                            Ok(())
         230  +
                        })?;
         231  +
                        container
  174    232   
                    });
  175    233   
                }
  176    234   
                _ => {}
  177    235   
            }
  178    236   
            Ok(())
  179    237   
        })?;
  180    238   
        Ok(builder.build())
  181    239   
    }
  182    240   
}
  183    241   
impl ::aws_types::request_id::RequestId for ImportKeyPairOutput {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/import_snapshot.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 `ImportSnapshot`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ImportSnapshot;
    6      6   
impl ImportSnapshot {
    7      7   
    /// Creates a new `ImportSnapshot`
    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::import_snapshot::ImportSnapshotInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::import_snapshot::ImportSnapshotOutput::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::import_snapshot::ImportSnapshotInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::import_snapshot::ImportSnapshotOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::import_snapshot::ImportSnapshotError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -116,120 +178,183 @@
  136    140   
                crate::operation::import_snapshot::ImportSnapshotError,
  137    141   
            >::new());
  138    142   
  139    143   
        ::std::borrow::Cow::Owned(rcb)
  140    144   
    }
  141    145   
}
  142    146   
  143    147   
#[derive(Debug)]
  144    148   
struct ImportSnapshotResponseDeserializer;
  145    149   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ImportSnapshotResponseDeserializer {
  146         -
    fn deserialize_nonstreaming(
         150  +
    fn deserialize_nonstreaming_with_config(
  147    151   
        &self,
  148    152   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         153  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  149    154   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  150    155   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  151    156   
        let headers = response.headers();
  152    157   
        let body = response.body().bytes().expect("body loaded");
  153    158   
        #[allow(unused_mut)]
  154    159   
        let mut force_error = false;
  155    160   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  156    161   
        let parse_result = if !success && status != 200 || force_error {
  157    162   
            crate::protocol_serde::shape_import_snapshot::de_import_snapshot_http_error(status, headers, body)
  158    163   
        } else {

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

@@ -75,75 +215,215 @@
   95     95   
    "com.amazonaws.ec2.synthetic",
   96     96   
    "ImportSnapshotInput",
   97     97   
);
   98     98   
static IMPORTSNAPSHOTINPUT_MEMBER_CLIENT_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static(
  100    100   
        "com.amazonaws.ec2.synthetic#ImportSnapshotInput$ClientData",
  101    101   
        "com.amazonaws.ec2.synthetic",
  102    102   
        "ImportSnapshotInput",
  103    103   
    ),
  104    104   
    ::aws_smithy_schema::ShapeType::Structure,
  105         -
    "client_data",
         105  +
    "ClientData",
  106    106   
    0,
  107    107   
);
  108    108   
static IMPORTSNAPSHOTINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static(
  110    110   
        "com.amazonaws.ec2.synthetic#ImportSnapshotInput$ClientToken",
  111    111   
        "com.amazonaws.ec2.synthetic",
  112    112   
        "ImportSnapshotInput",
  113    113   
    ),
  114    114   
    ::aws_smithy_schema::ShapeType::String,
  115         -
    "client_token",
         115  +
    "ClientToken",
  116    116   
    1,
  117    117   
);
  118    118   
static IMPORTSNAPSHOTINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.ec2.synthetic#ImportSnapshotInput$Description",
  121    121   
        "com.amazonaws.ec2.synthetic",
  122    122   
        "ImportSnapshotInput",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::String,
  125         -
    "description",
         125  +
    "Description",
  126    126   
    2,
  127    127   
);
  128    128   
static IMPORTSNAPSHOTINPUT_MEMBER_DISK_CONTAINER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static(
  130    130   
        "com.amazonaws.ec2.synthetic#ImportSnapshotInput$DiskContainer",
  131    131   
        "com.amazonaws.ec2.synthetic",
  132    132   
        "ImportSnapshotInput",
  133    133   
    ),
  134    134   
    ::aws_smithy_schema::ShapeType::Structure,
  135         -
    "disk_container",
         135  +
    "DiskContainer",
  136    136   
    3,
  137    137   
);
  138    138   
static IMPORTSNAPSHOTINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  139    139   
    ::aws_smithy_schema::ShapeId::from_static(
  140    140   
        "com.amazonaws.ec2.synthetic#ImportSnapshotInput$DryRun",
  141    141   
        "com.amazonaws.ec2.synthetic",
  142    142   
        "ImportSnapshotInput",
  143    143   
    ),
  144    144   
    ::aws_smithy_schema::ShapeType::Boolean,
  145         -
    "dry_run",
         145  +
    "DryRun",
  146    146   
    4,
  147    147   
);
  148    148   
static IMPORTSNAPSHOTINPUT_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  149    149   
    ::aws_smithy_schema::ShapeId::from_static(
  150    150   
        "com.amazonaws.ec2.synthetic#ImportSnapshotInput$Encrypted",
  151    151   
        "com.amazonaws.ec2.synthetic",
  152    152   
        "ImportSnapshotInput",
  153    153   
    ),
  154    154   
    ::aws_smithy_schema::ShapeType::Boolean,
  155         -
    "encrypted",
         155  +
    "Encrypted",
  156    156   
    5,
  157    157   
);
  158    158   
static IMPORTSNAPSHOTINPUT_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  159    159   
    ::aws_smithy_schema::ShapeId::from_static(
  160    160   
        "com.amazonaws.ec2.synthetic#ImportSnapshotInput$KmsKeyId",
  161    161   
        "com.amazonaws.ec2.synthetic",
  162    162   
        "ImportSnapshotInput",
  163    163   
    ),
  164    164   
    ::aws_smithy_schema::ShapeType::String,
  165         -
    "kms_key_id",
         165  +
    "KmsKeyId",
  166    166   
    6,
  167    167   
);
  168    168   
static IMPORTSNAPSHOTINPUT_MEMBER_ROLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  169    169   
    ::aws_smithy_schema::ShapeId::from_static(
  170    170   
        "com.amazonaws.ec2.synthetic#ImportSnapshotInput$RoleName",
  171    171   
        "com.amazonaws.ec2.synthetic",
  172    172   
        "ImportSnapshotInput",
  173    173   
    ),
  174    174   
    ::aws_smithy_schema::ShapeType::String,
  175         -
    "role_name",
         175  +
    "RoleName",
  176    176   
    7,
  177    177   
);
  178    178   
static IMPORTSNAPSHOTINPUT_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static(
  180    180   
        "com.amazonaws.ec2.synthetic#ImportSnapshotInput$TagSpecifications",
  181    181   
        "com.amazonaws.ec2.synthetic",
  182    182   
        "ImportSnapshotInput",
  183    183   
    ),
  184    184   
    ::aws_smithy_schema::ShapeType::List,
  185         -
    "tag_specifications",
         185  +
    "TagSpecifications",
  186    186   
    8,
  187    187   
)
  188    188   
.with_xml_name("TagSpecification");
  189    189   
static IMPORTSNAPSHOTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  190    190   
    IMPORTSNAPSHOTINPUT_SCHEMA_ID,
  191    191   
    ::aws_smithy_schema::ShapeType::Structure,
  192    192   
    &[
  193    193   
        &IMPORTSNAPSHOTINPUT_MEMBER_CLIENT_DATA,
  194    194   
        &IMPORTSNAPSHOTINPUT_MEMBER_CLIENT_TOKEN,
  195    195   
        &IMPORTSNAPSHOTINPUT_MEMBER_DESCRIPTION,
@@ -224,224 +343,351 @@
  244    244   
                    }
  245    245   
                    Ok(())
  246    246   
                },
  247    247   
            )?;
  248    248   
        }
  249    249   
        Ok(())
  250    250   
    }
  251    251   
}
  252    252   
impl ImportSnapshotInput {
  253    253   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  254         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  255         -
        deserializer: &mut D,
         254  +
    pub fn deserialize(
         255  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  256    256   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  257    257   
        #[allow(unused_variables, unused_mut)]
  258    258   
        let mut builder = Self::builder();
  259    259   
        #[allow(
  260    260   
            unused_variables,
  261    261   
            unreachable_code,
  262    262   
            clippy::single_match,
  263    263   
            clippy::match_single_binding,
  264    264   
            clippy::diverging_sub_expression
  265    265   
        )]
  266         -
        deserializer.read_struct(&IMPORTSNAPSHOTINPUT_SCHEMA, (), |_, member, deser| {
         266  +
        deserializer.read_struct(&IMPORTSNAPSHOTINPUT_SCHEMA, &mut |member, deser| {
  267    267   
            match member.member_index() {
  268    268   
                Some(0) => {
  269    269   
                    builder.client_data = Some(crate::types::ClientData::deserialize(deser)?);
  270    270   
                }
  271    271   
                Some(1) => {
  272    272   
                    builder.client_token = Some(deser.read_string(member)?);
  273    273   
                }
  274    274   
                Some(2) => {
  275    275   
                    builder.description = Some(deser.read_string(member)?);
  276    276   
                }
  277    277   
                Some(3) => {
  278    278   
                    builder.disk_container = Some(crate::types::SnapshotDiskContainer::deserialize(deser)?);
  279    279   
                }
  280    280   
                Some(4) => {
  281    281   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  282    282   
                }
  283    283   
                Some(5) => {
  284    284   
                    builder.encrypted = Some(deser.read_boolean(member)?);
  285    285   
                }
  286    286   
                Some(6) => {
  287    287   
                    builder.kms_key_id = Some(deser.read_string(member)?);
  288    288   
                }
  289    289   
                Some(7) => {
  290    290   
                    builder.role_name = Some(deser.read_string(member)?);
  291    291   
                }
  292    292   
                Some(8) => {
  293    293   
                    builder.tag_specifications = Some({
  294         -
                        let container = if let Some(cap) = deser.container_size() {
  295         -
                            Vec::with_capacity(cap)
  296         -
                        } else {
  297         -
                            Vec::new()
  298         -
                        };
  299         -
                        deser.read_list(member, container, |mut list, deser| {
  300         -
                            list.push(crate::types::TagSpecification::deserialize(deser)?);
  301         -
                            Ok(list)
  302         -
                        })?
         294  +
                        let mut container = Vec::new();
         295  +
                        deser.read_list(member, &mut |deser| {
         296  +
                            container.push(crate::types::TagSpecification::deserialize(deser)?);
         297  +
                            Ok(())
         298  +
                        })?;
         299  +
                        container
  303    300   
                    });
  304    301   
                }
  305    302   
                _ => {}
  306    303   
            }
  307    304   
            Ok(())
  308    305   
        })?;
  309    306   
        builder
  310    307   
            .build()
  311    308   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  312    309   
    }
  313    310   
}
         311  +
impl ImportSnapshotInput {
         312  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         313  +
    pub fn deserialize_with_response(
         314  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         315  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         316  +
        _status: u16,
         317  +
        _body: &[u8],
         318  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         319  +
        Self::deserialize(deserializer)
         320  +
    }
         321  +
}
  314    322   
impl ImportSnapshotInput {
  315    323   
    /// Creates a new builder-style object to manufacture [`ImportSnapshotInput`](crate::operation::import_snapshot::ImportSnapshotInput).
  316    324   
    pub fn builder() -> crate::operation::import_snapshot::builders::ImportSnapshotInputBuilder {
  317    325   
        crate::operation::import_snapshot::builders::ImportSnapshotInputBuilder::default()
  318    326   
    }
  319    327   
}
  320    328   
  321    329   
/// A builder for [`ImportSnapshotInput`](crate::operation::import_snapshot::ImportSnapshotInput).
  322    330   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  323    331   
#[non_exhaustive]

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

@@ -18,18 +193,251 @@
   38     38   
    "com.amazonaws.ec2.synthetic",
   39     39   
    "ImportSnapshotOutput",
   40     40   
);
   41     41   
static IMPORTSNAPSHOTOUTPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   42     42   
    ::aws_smithy_schema::ShapeId::from_static(
   43     43   
        "com.amazonaws.ec2.synthetic#ImportSnapshotOutput$Description",
   44     44   
        "com.amazonaws.ec2.synthetic",
   45     45   
        "ImportSnapshotOutput",
   46     46   
    ),
   47     47   
    ::aws_smithy_schema::ShapeType::String,
   48         -
    "description",
          48  +
    "Description",
   49     49   
    0,
   50     50   
)
   51     51   
.with_xml_name("description");
   52     52   
static IMPORTSNAPSHOTOUTPUT_MEMBER_IMPORT_TASK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.ec2.synthetic#ImportSnapshotOutput$ImportTaskId",
   55     55   
        "com.amazonaws.ec2.synthetic",
   56     56   
        "ImportSnapshotOutput",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::String,
   59         -
    "import_task_id",
          59  +
    "ImportTaskId",
   60     60   
    1,
   61     61   
)
   62     62   
.with_xml_name("importTaskId");
   63     63   
static IMPORTSNAPSHOTOUTPUT_MEMBER_SNAPSHOT_TASK_DETAIL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.ec2.synthetic#ImportSnapshotOutput$SnapshotTaskDetail",
   66     66   
        "com.amazonaws.ec2.synthetic",
   67     67   
        "ImportSnapshotOutput",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::Structure,
   70         -
    "snapshot_task_detail",
          70  +
    "SnapshotTaskDetail",
   71     71   
    2,
   72     72   
)
   73     73   
.with_xml_name("snapshotTaskDetail");
   74     74   
static IMPORTSNAPSHOTOUTPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "com.amazonaws.ec2.synthetic#ImportSnapshotOutput$Tags",
   77     77   
        "com.amazonaws.ec2.synthetic",
   78     78   
        "ImportSnapshotOutput",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::List,
   81         -
    "tags",
          81  +
    "Tags",
   82     82   
    3,
   83     83   
)
   84     84   
.with_xml_name("tagSet");
          85  +
static IMPORTSNAPSHOTOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          86  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          87  +
    ::aws_smithy_schema::ShapeType::String,
          88  +
    "request_id",
          89  +
    4,
          90  +
)
          91  +
.with_http_header("x-amzn-requestid");
   85     92   
static IMPORTSNAPSHOTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   86     93   
    IMPORTSNAPSHOTOUTPUT_SCHEMA_ID,
   87     94   
    ::aws_smithy_schema::ShapeType::Structure,
   88     95   
    &[
   89     96   
        &IMPORTSNAPSHOTOUTPUT_MEMBER_DESCRIPTION,
   90     97   
        &IMPORTSNAPSHOTOUTPUT_MEMBER_IMPORT_TASK_ID,
   91     98   
        &IMPORTSNAPSHOTOUTPUT_MEMBER_SNAPSHOT_TASK_DETAIL,
   92     99   
        &IMPORTSNAPSHOTOUTPUT_MEMBER_TAGS,
         100  +
        &IMPORTSNAPSHOTOUTPUT_MEMBER__REQUEST_ID,
   93    101   
    ],
   94    102   
);
   95    103   
impl ImportSnapshotOutput {
   96    104   
    /// The schema for this shape.
   97    105   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IMPORTSNAPSHOTOUTPUT_SCHEMA;
   98    106   
}
   99    107   
impl ::aws_smithy_schema::serde::SerializableStruct for ImportSnapshotOutput {
  100    108   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  101    109   
    fn serialize_members(
  102    110   
        &self,
  103    111   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  104    112   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  105    113   
        if let Some(ref val) = self.description {
  106    114   
            ser.write_string(&IMPORTSNAPSHOTOUTPUT_MEMBER_DESCRIPTION, val)?;
  107    115   
        }
  108    116   
        if let Some(ref val) = self.import_task_id {
  109    117   
            ser.write_string(&IMPORTSNAPSHOTOUTPUT_MEMBER_IMPORT_TASK_ID, val)?;
  110    118   
        }
  111    119   
        if let Some(ref val) = self.snapshot_task_detail {
  112    120   
            ser.write_struct(&IMPORTSNAPSHOTOUTPUT_MEMBER_SNAPSHOT_TASK_DETAIL, val)?;
  113    121   
        }
  114    122   
        if let Some(ref val) = self.tags {
  115    123   
            ser.write_list(
  116    124   
                &IMPORTSNAPSHOTOUTPUT_MEMBER_TAGS,
  117    125   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  118    126   
                    for item in val {
  119    127   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  120    128   
                    }
  121    129   
                    Ok(())
  122    130   
                },
  123    131   
            )?;
  124    132   
        }
  125    133   
        Ok(())
  126    134   
    }
  127    135   
}
  128    136   
impl ImportSnapshotOutput {
  129    137   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  130         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  131         -
        deserializer: &mut D,
         138  +
    pub fn deserialize(
         139  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         140  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         141  +
        #[allow(unused_variables, unused_mut)]
         142  +
        let mut builder = Self::builder();
         143  +
        #[allow(
         144  +
            unused_variables,
         145  +
            unreachable_code,
         146  +
            clippy::single_match,
         147  +
            clippy::match_single_binding,
         148  +
            clippy::diverging_sub_expression
         149  +
        )]
         150  +
        deserializer.read_struct(&IMPORTSNAPSHOTOUTPUT_SCHEMA, &mut |member, deser| {
         151  +
            match member.member_index() {
         152  +
                Some(0) => {
         153  +
                    builder.description = Some(deser.read_string(member)?);
         154  +
                }
         155  +
                Some(1) => {
         156  +
                    builder.import_task_id = Some(deser.read_string(member)?);
         157  +
                }
         158  +
                Some(2) => {
         159  +
                    builder.snapshot_task_detail = Some(crate::types::SnapshotTaskDetail::deserialize(deser)?);
         160  +
                }
         161  +
                Some(3) => {
         162  +
                    builder.tags = Some({
         163  +
                        let mut container = Vec::new();
         164  +
                        deser.read_list(member, &mut |deser| {
         165  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         166  +
                            Ok(())
         167  +
                        })?;
         168  +
                        container
         169  +
                    });
         170  +
                }
         171  +
                Some(4) => {
         172  +
                    builder._request_id = Some(deser.read_string(member)?);
         173  +
                }
         174  +
                _ => {}
         175  +
            }
         176  +
            Ok(())
         177  +
        })?;
         178  +
        Ok(builder.build())
         179  +
    }
         180  +
}
         181  +
impl ImportSnapshotOutput {
         182  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         183  +
    /// Header-bound members are read directly from headers, avoiding runtime
         184  +
    /// member iteration overhead. Body members are read via the deserializer.
         185  +
    pub fn deserialize_with_response(
         186  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         187  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         188  +
        _status: u16,
         189  +
        _body: &[u8],
  132    190   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  133    191   
        #[allow(unused_variables, unused_mut)]
  134    192   
        let mut builder = Self::builder();
         193  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         194  +
            builder._request_id = Some(val.to_string());
         195  +
        }
  135    196   
        #[allow(
  136    197   
            unused_variables,
  137    198   
            unreachable_code,
  138    199   
            clippy::single_match,
  139    200   
            clippy::match_single_binding,
  140    201   
            clippy::diverging_sub_expression
  141    202   
        )]
  142         -
        deserializer.read_struct(&IMPORTSNAPSHOTOUTPUT_SCHEMA, (), |_, member, deser| {
         203  +
        deserializer.read_struct(&IMPORTSNAPSHOTOUTPUT_SCHEMA, &mut |member, deser| {
  143    204   
            match member.member_index() {
  144    205   
                Some(0) => {
  145    206   
                    builder.description = Some(deser.read_string(member)?);
  146    207   
                }
  147    208   
                Some(1) => {
  148    209   
                    builder.import_task_id = Some(deser.read_string(member)?);
  149    210   
                }
  150    211   
                Some(2) => {
  151    212   
                    builder.snapshot_task_detail = Some(crate::types::SnapshotTaskDetail::deserialize(deser)?);
  152    213   
                }
  153    214   
                Some(3) => {
  154    215   
                    builder.tags = Some({
  155         -
                        let container = if let Some(cap) = deser.container_size() {
  156         -
                            Vec::with_capacity(cap)
  157         -
                        } else {
  158         -
                            Vec::new()
  159         -
                        };
  160         -
                        deser.read_list(member, container, |mut list, deser| {
  161         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  162         -
                            Ok(list)
  163         -
                        })?
         216  +
                        let mut container = Vec::new();
         217  +
                        deser.read_list(member, &mut |deser| {
         218  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         219  +
                            Ok(())
         220  +
                        })?;
         221  +
                        container
  164    222   
                    });
  165    223   
                }
  166    224   
                _ => {}
  167    225   
            }
  168    226   
            Ok(())
  169    227   
        })?;
  170    228   
        Ok(builder.build())
  171    229   
    }
  172    230   
}
  173    231   
impl ::aws_types::request_id::RequestId for ImportSnapshotOutput {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/import_volume.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 `ImportVolume`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ImportVolume;
    6      6   
impl ImportVolume {
    7      7   
    /// Creates a new `ImportVolume`
    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::import_volume::ImportVolumeInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::import_volume::ImportVolumeOutput::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::import_volume::ImportVolumeInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::import_volume::ImportVolumeOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::import_volume::ImportVolumeError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -116,120 +178,183 @@
  136    140   
                crate::operation::import_volume::ImportVolumeError,
  137    141   
            >::new());
  138    142   
  139    143   
        ::std::borrow::Cow::Owned(rcb)
  140    144   
    }
  141    145   
}
  142    146   
  143    147   
#[derive(Debug)]
  144    148   
struct ImportVolumeResponseDeserializer;
  145    149   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ImportVolumeResponseDeserializer {
  146         -
    fn deserialize_nonstreaming(
         150  +
    fn deserialize_nonstreaming_with_config(
  147    151   
        &self,
  148    152   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         153  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  149    154   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  150    155   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  151    156   
        let headers = response.headers();
  152    157   
        let body = response.body().bytes().expect("body loaded");
  153    158   
        #[allow(unused_mut)]
  154    159   
        let mut force_error = false;
  155    160   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  156    161   
        let parse_result = if !success && status != 200 || force_error {
  157    162   
            crate::protocol_serde::shape_import_volume::de_import_volume_http_error(status, headers, body)
  158    163   
        } else {