AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c (ignoring whitespace)

Files changed:

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

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

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

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

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

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

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

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

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

@@ -58,58 +309,384 @@
   78     78   
    "com.amazonaws.ec2.synthetic",
   79     79   
    "RestoreSnapshotFromRecycleBinOutput",
   80     80   
);
   81     81   
static RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotFromRecycleBinOutput$SnapshotId",
   84     84   
        "com.amazonaws.ec2.synthetic",
   85     85   
        "RestoreSnapshotFromRecycleBinOutput",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::String,
   88         -
    "snapshot_id",
          88  +
    "SnapshotId",
   89     89   
    0,
   90     90   
)
   91     91   
.with_xml_name("snapshotId");
   92     92   
static RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_OUTPOST_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotFromRecycleBinOutput$OutpostArn",
   95     95   
        "com.amazonaws.ec2.synthetic",
   96     96   
        "RestoreSnapshotFromRecycleBinOutput",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "outpost_arn",
          99  +
    "OutpostArn",
  100    100   
    1,
  101    101   
)
  102    102   
.with_xml_name("outpostArn");
  103    103   
static RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotFromRecycleBinOutput$Description",
  106    106   
        "com.amazonaws.ec2.synthetic",
  107    107   
        "RestoreSnapshotFromRecycleBinOutput",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::String,
  110         -
    "description",
         110  +
    "Description",
  111    111   
    2,
  112    112   
)
  113    113   
.with_xml_name("description");
  114    114   
static RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotFromRecycleBinOutput$Encrypted",
  117    117   
        "com.amazonaws.ec2.synthetic",
  118    118   
        "RestoreSnapshotFromRecycleBinOutput",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::Boolean,
  121         -
    "encrypted",
         121  +
    "Encrypted",
  122    122   
    3,
  123    123   
)
  124    124   
.with_xml_name("encrypted");
  125    125   
static RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotFromRecycleBinOutput$OwnerId",
  128    128   
        "com.amazonaws.ec2.synthetic",
  129    129   
        "RestoreSnapshotFromRecycleBinOutput",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::String,
  132         -
    "owner_id",
         132  +
    "OwnerId",
  133    133   
    4,
  134    134   
)
  135    135   
.with_xml_name("ownerId");
  136    136   
static RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_PROGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  137    137   
    ::aws_smithy_schema::ShapeId::from_static(
  138    138   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotFromRecycleBinOutput$Progress",
  139    139   
        "com.amazonaws.ec2.synthetic",
  140    140   
        "RestoreSnapshotFromRecycleBinOutput",
  141    141   
    ),
  142    142   
    ::aws_smithy_schema::ShapeType::String,
  143         -
    "progress",
         143  +
    "Progress",
  144    144   
    5,
  145    145   
)
  146    146   
.with_xml_name("progress");
  147    147   
static RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  148    148   
    ::aws_smithy_schema::ShapeId::from_static(
  149    149   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotFromRecycleBinOutput$StartTime",
  150    150   
        "com.amazonaws.ec2.synthetic",
  151    151   
        "RestoreSnapshotFromRecycleBinOutput",
  152    152   
    ),
  153    153   
    ::aws_smithy_schema::ShapeType::Timestamp,
  154         -
    "start_time",
         154  +
    "StartTime",
  155    155   
    6,
  156    156   
)
  157    157   
.with_xml_name("startTime");
  158    158   
static RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  159    159   
    ::aws_smithy_schema::ShapeId::from_static(
  160    160   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotFromRecycleBinOutput$State",
  161    161   
        "com.amazonaws.ec2.synthetic",
  162    162   
        "RestoreSnapshotFromRecycleBinOutput",
  163    163   
    ),
  164    164   
    ::aws_smithy_schema::ShapeType::String,
  165         -
    "state",
         165  +
    "State",
  166    166   
    7,
  167    167   
)
  168    168   
.with_xml_name("status");
  169    169   
static RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_VOLUME_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  170    170   
    ::aws_smithy_schema::ShapeId::from_static(
  171    171   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotFromRecycleBinOutput$VolumeId",
  172    172   
        "com.amazonaws.ec2.synthetic",
  173    173   
        "RestoreSnapshotFromRecycleBinOutput",
  174    174   
    ),
  175    175   
    ::aws_smithy_schema::ShapeType::String,
  176         -
    "volume_id",
         176  +
    "VolumeId",
  177    177   
    8,
  178    178   
)
  179    179   
.with_xml_name("volumeId");
  180    180   
static RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_VOLUME_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  181    181   
    ::aws_smithy_schema::ShapeId::from_static(
  182    182   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotFromRecycleBinOutput$VolumeSize",
  183    183   
        "com.amazonaws.ec2.synthetic",
  184    184   
        "RestoreSnapshotFromRecycleBinOutput",
  185    185   
    ),
  186    186   
    ::aws_smithy_schema::ShapeType::Integer,
  187         -
    "volume_size",
         187  +
    "VolumeSize",
  188    188   
    9,
  189    189   
)
  190    190   
.with_xml_name("volumeSize");
  191    191   
static RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_SSE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  192    192   
    ::aws_smithy_schema::ShapeId::from_static(
  193    193   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotFromRecycleBinOutput$SseType",
  194    194   
        "com.amazonaws.ec2.synthetic",
  195    195   
        "RestoreSnapshotFromRecycleBinOutput",
  196    196   
    ),
  197    197   
    ::aws_smithy_schema::ShapeType::String,
  198         -
    "sse_type",
         198  +
    "SseType",
  199    199   
    10,
  200    200   
)
  201    201   
.with_xml_name("sseType");
         202  +
static RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         203  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         204  +
    ::aws_smithy_schema::ShapeType::String,
         205  +
    "request_id",
         206  +
    11,
         207  +
)
         208  +
.with_http_header("x-amzn-requestid");
  202    209   
static RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  203    210   
    RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_SCHEMA_ID,
  204    211   
    ::aws_smithy_schema::ShapeType::Structure,
  205    212   
    &[
  206    213   
        &RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_SNAPSHOT_ID,
  207    214   
        &RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_OUTPOST_ARN,
  208    215   
        &RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_DESCRIPTION,
  209    216   
        &RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_ENCRYPTED,
  210    217   
        &RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_OWNER_ID,
  211    218   
        &RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_PROGRESS,
  212    219   
        &RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_START_TIME,
  213    220   
        &RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_STATE,
  214    221   
        &RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_VOLUME_ID,
  215    222   
        &RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_VOLUME_SIZE,
  216    223   
        &RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_SSE_TYPE,
         224  +
        &RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER__REQUEST_ID,
  217    225   
    ],
  218    226   
);
  219    227   
impl RestoreSnapshotFromRecycleBinOutput {
  220    228   
    /// The schema for this shape.
  221    229   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_SCHEMA;
  222    230   
}
  223    231   
impl ::aws_smithy_schema::serde::SerializableStruct for RestoreSnapshotFromRecycleBinOutput {
  224    232   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  225    233   
    fn serialize_members(
  226    234   
        &self,
  227    235   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  228    236   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  229    237   
        if let Some(ref val) = self.snapshot_id {
  230    238   
            ser.write_string(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_SNAPSHOT_ID, val)?;
  231    239   
        }
  232    240   
        if let Some(ref val) = self.outpost_arn {
  233    241   
            ser.write_string(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_OUTPOST_ARN, val)?;
  234    242   
        }
  235    243   
        if let Some(ref val) = self.description {
  236    244   
            ser.write_string(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_DESCRIPTION, val)?;
  237    245   
        }
  238    246   
        if let Some(ref val) = self.encrypted {
  239    247   
            ser.write_boolean(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_ENCRYPTED, *val)?;
  240    248   
        }
  241    249   
        if let Some(ref val) = self.owner_id {
  242    250   
            ser.write_string(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_OWNER_ID, val)?;
  243    251   
        }
  244    252   
        if let Some(ref val) = self.progress {
  245    253   
            ser.write_string(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_PROGRESS, val)?;
  246    254   
        }
  247    255   
        if let Some(ref val) = self.start_time {
  248    256   
            ser.write_timestamp(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_START_TIME, val)?;
  249    257   
        }
  250    258   
        if let Some(ref val) = self.state {
  251    259   
            ser.write_string(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_STATE, val.as_str())?;
  252    260   
        }
  253    261   
        if let Some(ref val) = self.volume_id {
  254    262   
            ser.write_string(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_VOLUME_ID, val)?;
  255    263   
        }
  256    264   
        if let Some(ref val) = self.volume_size {
  257    265   
            ser.write_integer(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_VOLUME_SIZE, *val)?;
  258    266   
        }
  259    267   
        if let Some(ref val) = self.sse_type {
  260    268   
            ser.write_string(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_MEMBER_SSE_TYPE, val.as_str())?;
  261    269   
        }
  262    270   
        Ok(())
  263    271   
    }
  264    272   
}
  265    273   
impl RestoreSnapshotFromRecycleBinOutput {
  266    274   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  267         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  268         -
        deserializer: &mut D,
         275  +
    pub fn deserialize(
         276  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         277  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         278  +
        #[allow(unused_variables, unused_mut)]
         279  +
        let mut builder = Self::builder();
         280  +
        #[allow(
         281  +
            unused_variables,
         282  +
            unreachable_code,
         283  +
            clippy::single_match,
         284  +
            clippy::match_single_binding,
         285  +
            clippy::diverging_sub_expression
         286  +
        )]
         287  +
        deserializer.read_struct(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_SCHEMA, &mut |member, deser| {
         288  +
            match member.member_index() {
         289  +
                Some(0) => {
         290  +
                    builder.snapshot_id = Some(deser.read_string(member)?);
         291  +
                }
         292  +
                Some(1) => {
         293  +
                    builder.outpost_arn = Some(deser.read_string(member)?);
         294  +
                }
         295  +
                Some(2) => {
         296  +
                    builder.description = Some(deser.read_string(member)?);
         297  +
                }
         298  +
                Some(3) => {
         299  +
                    builder.encrypted = Some(deser.read_boolean(member)?);
         300  +
                }
         301  +
                Some(4) => {
         302  +
                    builder.owner_id = Some(deser.read_string(member)?);
         303  +
                }
         304  +
                Some(5) => {
         305  +
                    builder.progress = Some(deser.read_string(member)?);
         306  +
                }
         307  +
                Some(6) => {
         308  +
                    builder.start_time = Some(deser.read_timestamp(member)?);
         309  +
                }
         310  +
                Some(7) => {
         311  +
                    builder.state = Some(crate::types::SnapshotState::from(deser.read_string(member)?.as_str()));
         312  +
                }
         313  +
                Some(8) => {
         314  +
                    builder.volume_id = Some(deser.read_string(member)?);
         315  +
                }
         316  +
                Some(9) => {
         317  +
                    builder.volume_size = Some(deser.read_integer(member)?);
         318  +
                }
         319  +
                Some(10) => {
         320  +
                    builder.sse_type = Some(crate::types::SseType::from(deser.read_string(member)?.as_str()));
         321  +
                }
         322  +
                Some(11) => {
         323  +
                    builder._request_id = Some(deser.read_string(member)?);
         324  +
                }
         325  +
                _ => {}
         326  +
            }
         327  +
            Ok(())
         328  +
        })?;
         329  +
        Ok(builder.build())
         330  +
    }
         331  +
}
         332  +
impl RestoreSnapshotFromRecycleBinOutput {
         333  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         334  +
    /// Header-bound members are read directly from headers, avoiding runtime
         335  +
    /// member iteration overhead. Body members are read via the deserializer.
         336  +
    pub fn deserialize_with_response(
         337  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         338  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         339  +
        _status: u16,
         340  +
        _body: &[u8],
  269    341   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  270    342   
        #[allow(unused_variables, unused_mut)]
  271    343   
        let mut builder = Self::builder();
         344  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         345  +
            builder._request_id = Some(val.to_string());
         346  +
        }
  272    347   
        #[allow(
  273    348   
            unused_variables,
  274    349   
            unreachable_code,
  275    350   
            clippy::single_match,
  276    351   
            clippy::match_single_binding,
  277    352   
            clippy::diverging_sub_expression
  278    353   
        )]
  279         -
        deserializer.read_struct(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_SCHEMA, (), |_, member, deser| {
         354  +
        deserializer.read_struct(&RESTORESNAPSHOTFROMRECYCLEBINOUTPUT_SCHEMA, &mut |member, deser| {
  280    355   
            match member.member_index() {
  281    356   
                Some(0) => {
  282    357   
                    builder.snapshot_id = Some(deser.read_string(member)?);
  283    358   
                }
  284    359   
                Some(1) => {
  285    360   
                    builder.outpost_arn = Some(deser.read_string(member)?);
  286    361   
                }
  287    362   
                Some(2) => {
  288    363   
                    builder.description = Some(deser.read_string(member)?);
  289    364   
                }

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

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

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

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

@@ -16,16 +162,216 @@
   36     36   
    "com.amazonaws.ec2.synthetic",
   37     37   
    "RestoreSnapshotTierOutput",
   38     38   
);
   39     39   
static RESTORESNAPSHOTTIEROUTPUT_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotTierOutput$SnapshotId",
   42     42   
        "com.amazonaws.ec2.synthetic",
   43     43   
        "RestoreSnapshotTierOutput",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "snapshot_id",
          46  +
    "SnapshotId",
   47     47   
    0,
   48     48   
)
   49     49   
.with_xml_name("snapshotId");
   50     50   
static RESTORESNAPSHOTTIEROUTPUT_MEMBER_RESTORE_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotTierOutput$RestoreStartTime",
   53     53   
        "com.amazonaws.ec2.synthetic",
   54     54   
        "RestoreSnapshotTierOutput",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::Timestamp,
   57         -
    "restore_start_time",
          57  +
    "RestoreStartTime",
   58     58   
    1,
   59     59   
)
   60     60   
.with_xml_name("restoreStartTime");
   61     61   
static RESTORESNAPSHOTTIEROUTPUT_MEMBER_RESTORE_DURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotTierOutput$RestoreDuration",
   64     64   
        "com.amazonaws.ec2.synthetic",
   65     65   
        "RestoreSnapshotTierOutput",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::Integer,
   68         -
    "restore_duration",
          68  +
    "RestoreDuration",
   69     69   
    2,
   70     70   
)
   71     71   
.with_xml_name("restoreDuration");
   72     72   
static RESTORESNAPSHOTTIEROUTPUT_MEMBER_IS_PERMANENT_RESTORE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.ec2.synthetic#RestoreSnapshotTierOutput$IsPermanentRestore",
   75     75   
        "com.amazonaws.ec2.synthetic",
   76     76   
        "RestoreSnapshotTierOutput",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::Boolean,
   79         -
    "is_permanent_restore",
          79  +
    "IsPermanentRestore",
   80     80   
    3,
   81     81   
)
   82     82   
.with_xml_name("isPermanentRestore");
          83  +
static RESTORESNAPSHOTTIEROUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          84  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          85  +
    ::aws_smithy_schema::ShapeType::String,
          86  +
    "request_id",
          87  +
    4,
          88  +
)
          89  +
.with_http_header("x-amzn-requestid");
   83     90   
static RESTORESNAPSHOTTIEROUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   84     91   
    RESTORESNAPSHOTTIEROUTPUT_SCHEMA_ID,
   85     92   
    ::aws_smithy_schema::ShapeType::Structure,
   86     93   
    &[
   87     94   
        &RESTORESNAPSHOTTIEROUTPUT_MEMBER_SNAPSHOT_ID,
   88     95   
        &RESTORESNAPSHOTTIEROUTPUT_MEMBER_RESTORE_START_TIME,
   89     96   
        &RESTORESNAPSHOTTIEROUTPUT_MEMBER_RESTORE_DURATION,
   90     97   
        &RESTORESNAPSHOTTIEROUTPUT_MEMBER_IS_PERMANENT_RESTORE,
          98  +
        &RESTORESNAPSHOTTIEROUTPUT_MEMBER__REQUEST_ID,
   91     99   
    ],
   92    100   
);
   93    101   
impl RestoreSnapshotTierOutput {
   94    102   
    /// The schema for this shape.
   95    103   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESTORESNAPSHOTTIEROUTPUT_SCHEMA;
   96    104   
}
   97    105   
impl ::aws_smithy_schema::serde::SerializableStruct for RestoreSnapshotTierOutput {
   98    106   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   99    107   
    fn serialize_members(
  100    108   
        &self,
  101    109   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  102    110   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  103    111   
        if let Some(ref val) = self.snapshot_id {
  104    112   
            ser.write_string(&RESTORESNAPSHOTTIEROUTPUT_MEMBER_SNAPSHOT_ID, val)?;
  105    113   
        }
  106    114   
        if let Some(ref val) = self.restore_start_time {
  107    115   
            ser.write_timestamp(&RESTORESNAPSHOTTIEROUTPUT_MEMBER_RESTORE_START_TIME, val)?;
  108    116   
        }
  109    117   
        if let Some(ref val) = self.restore_duration {
  110    118   
            ser.write_integer(&RESTORESNAPSHOTTIEROUTPUT_MEMBER_RESTORE_DURATION, *val)?;
  111    119   
        }
  112    120   
        if let Some(ref val) = self.is_permanent_restore {
  113    121   
            ser.write_boolean(&RESTORESNAPSHOTTIEROUTPUT_MEMBER_IS_PERMANENT_RESTORE, *val)?;
  114    122   
        }
  115    123   
        Ok(())
  116    124   
    }
  117    125   
}
  118    126   
impl RestoreSnapshotTierOutput {
  119    127   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  120         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  121         -
        deserializer: &mut D,
         128  +
    pub fn deserialize(
         129  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  122    130   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  123    131   
        #[allow(unused_variables, unused_mut)]
  124    132   
        let mut builder = Self::builder();
  125    133   
        #[allow(
  126    134   
            unused_variables,
  127    135   
            unreachable_code,
  128    136   
            clippy::single_match,
  129    137   
            clippy::match_single_binding,
  130    138   
            clippy::diverging_sub_expression
  131    139   
        )]
  132         -
        deserializer.read_struct(&RESTORESNAPSHOTTIEROUTPUT_SCHEMA, (), |_, member, deser| {
         140  +
        deserializer.read_struct(&RESTORESNAPSHOTTIEROUTPUT_SCHEMA, &mut |member, deser| {
         141  +
            match member.member_index() {
         142  +
                Some(0) => {
         143  +
                    builder.snapshot_id = Some(deser.read_string(member)?);
         144  +
                }
         145  +
                Some(1) => {
         146  +
                    builder.restore_start_time = Some(deser.read_timestamp(member)?);
         147  +
                }
         148  +
                Some(2) => {
         149  +
                    builder.restore_duration = Some(deser.read_integer(member)?);
         150  +
                }
         151  +
                Some(3) => {
         152  +
                    builder.is_permanent_restore = Some(deser.read_boolean(member)?);
         153  +
                }
         154  +
                Some(4) => {
         155  +
                    builder._request_id = Some(deser.read_string(member)?);
         156  +
                }
         157  +
                _ => {}
         158  +
            }
         159  +
            Ok(())
         160  +
        })?;
         161  +
        Ok(builder.build())
         162  +
    }
         163  +
}
         164  +
impl RestoreSnapshotTierOutput {
         165  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         166  +
    /// Header-bound members are read directly from headers, avoiding runtime
         167  +
    /// member iteration overhead. Body members are read via the deserializer.
         168  +
    pub fn deserialize_with_response(
         169  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         170  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         171  +
        _status: u16,
         172  +
        _body: &[u8],
         173  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         174  +
        #[allow(unused_variables, unused_mut)]
         175  +
        let mut builder = Self::builder();
         176  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         177  +
            builder._request_id = Some(val.to_string());
         178  +
        }
         179  +
        #[allow(
         180  +
            unused_variables,
         181  +
            unreachable_code,
         182  +
            clippy::single_match,
         183  +
            clippy::match_single_binding,
         184  +
            clippy::diverging_sub_expression
         185  +
        )]
         186  +
        deserializer.read_struct(&RESTORESNAPSHOTTIEROUTPUT_SCHEMA, &mut |member, deser| {
  133    187   
            match member.member_index() {
  134    188   
                Some(0) => {
  135    189   
                    builder.snapshot_id = Some(deser.read_string(member)?);
  136    190   
                }
  137    191   
                Some(1) => {
  138    192   
                    builder.restore_start_time = Some(deser.read_timestamp(member)?);
  139    193   
                }
  140    194   
                Some(2) => {
  141    195   
                    builder.restore_duration = Some(deser.read_integer(member)?);
  142    196   
                }

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

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

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

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

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

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

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

@@ -55,55 +214,214 @@
   75     75   
    "com.amazonaws.ec2.synthetic",
   76     76   
    "RevokeSecurityGroupEgressInput",
   77     77   
);
   78     78   
static REVOKESECURITYGROUPEGRESSINPUT_MEMBER_SECURITY_GROUP_RULE_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.ec2.synthetic#RevokeSecurityGroupEgressInput$SecurityGroupRuleIds",
   81     81   
        "com.amazonaws.ec2.synthetic",
   82     82   
        "RevokeSecurityGroupEgressInput",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::List,
   85         -
    "security_group_rule_ids",
          85  +
    "SecurityGroupRuleIds",
   86     86   
    0,
   87     87   
)
   88     88   
.with_xml_name("SecurityGroupRuleId");
   89     89   
static REVOKESECURITYGROUPEGRESSINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.ec2.synthetic#RevokeSecurityGroupEgressInput$DryRun",
   92     92   
        "com.amazonaws.ec2.synthetic",
   93     93   
        "RevokeSecurityGroupEgressInput",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::Boolean,
   96         -
    "dry_run",
          96  +
    "DryRun",
   97     97   
    1,
   98     98   
)
   99     99   
.with_xml_name("dryRun");
  100    100   
static REVOKESECURITYGROUPEGRESSINPUT_MEMBER_GROUP_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.ec2.synthetic#RevokeSecurityGroupEgressInput$GroupId",
  103    103   
        "com.amazonaws.ec2.synthetic",
  104    104   
        "RevokeSecurityGroupEgressInput",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::String,
  107         -
    "group_id",
         107  +
    "GroupId",
  108    108   
    2,
  109    109   
)
  110    110   
.with_xml_name("groupId");
  111    111   
static REVOKESECURITYGROUPEGRESSINPUT_MEMBER_SOURCE_SECURITY_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static(
  113    113   
        "com.amazonaws.ec2.synthetic#RevokeSecurityGroupEgressInput$SourceSecurityGroupName",
  114    114   
        "com.amazonaws.ec2.synthetic",
  115    115   
        "RevokeSecurityGroupEgressInput",
  116    116   
    ),
  117    117   
    ::aws_smithy_schema::ShapeType::String,
  118         -
    "source_security_group_name",
         118  +
    "SourceSecurityGroupName",
  119    119   
    3,
  120    120   
)
  121    121   
.with_xml_name("sourceSecurityGroupName");
  122    122   
static REVOKESECURITYGROUPEGRESSINPUT_MEMBER_SOURCE_SECURITY_GROUP_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  123    123   
    ::aws_smithy_schema::ShapeId::from_static(
  124    124   
        "com.amazonaws.ec2.synthetic#RevokeSecurityGroupEgressInput$SourceSecurityGroupOwnerId",
  125    125   
        "com.amazonaws.ec2.synthetic",
  126    126   
        "RevokeSecurityGroupEgressInput",
  127    127   
    ),
  128    128   
    ::aws_smithy_schema::ShapeType::String,
  129         -
    "source_security_group_owner_id",
         129  +
    "SourceSecurityGroupOwnerId",
  130    130   
    4,
  131    131   
)
  132    132   
.with_xml_name("sourceSecurityGroupOwnerId");
  133    133   
static REVOKESECURITYGROUPEGRESSINPUT_MEMBER_IP_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  134    134   
    ::aws_smithy_schema::ShapeId::from_static(
  135    135   
        "com.amazonaws.ec2.synthetic#RevokeSecurityGroupEgressInput$IpProtocol",
  136    136   
        "com.amazonaws.ec2.synthetic",
  137    137   
        "RevokeSecurityGroupEgressInput",
  138    138   
    ),
  139    139   
    ::aws_smithy_schema::ShapeType::String,
  140         -
    "ip_protocol",
         140  +
    "IpProtocol",
  141    141   
    5,
  142    142   
)
  143    143   
.with_xml_name("ipProtocol");
  144    144   
static REVOKESECURITYGROUPEGRESSINPUT_MEMBER_FROM_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "com.amazonaws.ec2.synthetic#RevokeSecurityGroupEgressInput$FromPort",
  147    147   
        "com.amazonaws.ec2.synthetic",
  148    148   
        "RevokeSecurityGroupEgressInput",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::Integer,
  151         -
    "from_port",
         151  +
    "FromPort",
  152    152   
    6,
  153    153   
)
  154    154   
.with_xml_name("fromPort");
  155    155   
static REVOKESECURITYGROUPEGRESSINPUT_MEMBER_TO_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  156    156   
    ::aws_smithy_schema::ShapeId::from_static(
  157    157   
        "com.amazonaws.ec2.synthetic#RevokeSecurityGroupEgressInput$ToPort",
  158    158   
        "com.amazonaws.ec2.synthetic",
  159    159   
        "RevokeSecurityGroupEgressInput",
  160    160   
    ),
  161    161   
    ::aws_smithy_schema::ShapeType::Integer,
  162         -
    "to_port",
         162  +
    "ToPort",
  163    163   
    7,
  164    164   
)
  165    165   
.with_xml_name("toPort");
  166    166   
static REVOKESECURITYGROUPEGRESSINPUT_MEMBER_CIDR_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  167    167   
    ::aws_smithy_schema::ShapeId::from_static(
  168    168   
        "com.amazonaws.ec2.synthetic#RevokeSecurityGroupEgressInput$CidrIp",
  169    169   
        "com.amazonaws.ec2.synthetic",
  170    170   
        "RevokeSecurityGroupEgressInput",
  171    171   
    ),
  172    172   
    ::aws_smithy_schema::ShapeType::String,
  173         -
    "cidr_ip",
         173  +
    "CidrIp",
  174    174   
    8,
  175    175   
)
  176    176   
.with_xml_name("cidrIp");
  177    177   
static REVOKESECURITYGROUPEGRESSINPUT_MEMBER_IP_PERMISSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  178    178   
    ::aws_smithy_schema::ShapeId::from_static(
  179    179   
        "com.amazonaws.ec2.synthetic#RevokeSecurityGroupEgressInput$IpPermissions",
  180    180   
        "com.amazonaws.ec2.synthetic",
  181    181   
        "RevokeSecurityGroupEgressInput",
  182    182   
    ),
  183    183   
    ::aws_smithy_schema::ShapeType::List,
  184         -
    "ip_permissions",
         184  +
    "IpPermissions",
  185    185   
    9,
  186    186   
)
  187    187   
.with_xml_name("ipPermissions");
  188    188   
static REVOKESECURITYGROUPEGRESSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  189    189   
    REVOKESECURITYGROUPEGRESSINPUT_SCHEMA_ID,
  190    190   
    ::aws_smithy_schema::ShapeType::Structure,
  191    191   
    &[
  192    192   
        &REVOKESECURITYGROUPEGRESSINPUT_MEMBER_SECURITY_GROUP_RULE_IDS,
  193    193   
        &REVOKESECURITYGROUPEGRESSINPUT_MEMBER_DRY_RUN,
  194    194   
        &REVOKESECURITYGROUPEGRESSINPUT_MEMBER_GROUP_ID,
@@ -235,235 +367,366 @@
  255    255   
                    }
  256    256   
                    Ok(())
  257    257   
                },
  258    258   
            )?;
  259    259   
        }
  260    260   
        Ok(())
  261    261   
    }
  262    262   
}
  263    263   
impl RevokeSecurityGroupEgressInput {
  264    264   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  265         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  266         -
        deserializer: &mut D,
         265  +
    pub fn deserialize(
         266  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  267    267   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  268    268   
        #[allow(unused_variables, unused_mut)]
  269    269   
        let mut builder = Self::builder();
  270    270   
        #[allow(
  271    271   
            unused_variables,
  272    272   
            unreachable_code,
  273    273   
            clippy::single_match,
  274    274   
            clippy::match_single_binding,
  275    275   
            clippy::diverging_sub_expression
  276    276   
        )]
  277         -
        deserializer.read_struct(&REVOKESECURITYGROUPEGRESSINPUT_SCHEMA, (), |_, member, deser| {
         277  +
        deserializer.read_struct(&REVOKESECURITYGROUPEGRESSINPUT_SCHEMA, &mut |member, deser| {
  278    278   
            match member.member_index() {
  279    279   
                Some(0) => {
  280         -
                    builder.security_group_rule_ids = Some({
  281         -
                        let container = if let Some(cap) = deser.container_size() {
  282         -
                            Vec::with_capacity(cap)
  283         -
                        } else {
  284         -
                            Vec::new()
  285         -
                        };
  286         -
                        deser.read_list(member, container, |mut list, deser| {
  287         -
                            list.push(deser.read_string(member)?);
  288         -
                            Ok(list)
  289         -
                        })?
  290         -
                    });
         280  +
                    builder.security_group_rule_ids = Some(deser.read_string_list(member)?);
  291    281   
                }
  292    282   
                Some(1) => {
  293    283   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  294    284   
                }
  295    285   
                Some(2) => {
  296    286   
                    builder.group_id = Some(deser.read_string(member)?);
  297    287   
                }
  298    288   
                Some(3) => {
  299    289   
                    builder.source_security_group_name = Some(deser.read_string(member)?);
  300    290   
                }
  301    291   
                Some(4) => {
  302    292   
                    builder.source_security_group_owner_id = Some(deser.read_string(member)?);
  303    293   
                }
  304    294   
                Some(5) => {
  305    295   
                    builder.ip_protocol = Some(deser.read_string(member)?);
  306    296   
                }
  307    297   
                Some(6) => {
  308    298   
                    builder.from_port = Some(deser.read_integer(member)?);
  309    299   
                }
  310    300   
                Some(7) => {
  311    301   
                    builder.to_port = Some(deser.read_integer(member)?);
  312    302   
                }
  313    303   
                Some(8) => {
  314    304   
                    builder.cidr_ip = Some(deser.read_string(member)?);
  315    305   
                }
  316    306   
                Some(9) => {
  317    307   
                    builder.ip_permissions = Some({
  318         -
                        let container = if let Some(cap) = deser.container_size() {
  319         -
                            Vec::with_capacity(cap)
  320         -
                        } else {
  321         -
                            Vec::new()
  322         -
                        };
  323         -
                        deser.read_list(member, container, |mut list, deser| {
  324         -
                            list.push(crate::types::IpPermission::deserialize(deser)?);
  325         -
                            Ok(list)
  326         -
                        })?
         308  +
                        let mut container = Vec::new();
         309  +
                        deser.read_list(member, &mut |deser| {
         310  +
                            container.push(crate::types::IpPermission::deserialize(deser)?);
         311  +
                            Ok(())
         312  +
                        })?;
         313  +
                        container
  327    314   
                    });
  328    315   
                }
  329    316   
                _ => {}
  330    317   
            }
  331    318   
            Ok(())
  332    319   
        })?;
         320  +
        builder.group_id = builder.group_id.or(Some(String::new()));
  333    321   
        builder
  334    322   
            .build()
  335    323   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  336    324   
    }
  337    325   
}
         326  +
impl RevokeSecurityGroupEgressInput {
         327  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         328  +
    pub fn deserialize_with_response(
         329  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         330  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         331  +
        _status: u16,
         332  +
        _body: &[u8],
         333  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         334  +
        Self::deserialize(deserializer)
         335  +
    }
         336  +
}
  338    337   
impl RevokeSecurityGroupEgressInput {
  339    338   
    /// Creates a new builder-style object to manufacture [`RevokeSecurityGroupEgressInput`](crate::operation::revoke_security_group_egress::RevokeSecurityGroupEgressInput).
  340    339   
    pub fn builder() -> crate::operation::revoke_security_group_egress::builders::RevokeSecurityGroupEgressInputBuilder {
  341    340   
        crate::operation::revoke_security_group_egress::builders::RevokeSecurityGroupEgressInputBuilder::default()
  342    341   
    }
  343    342   
}
  344    343   
  345    344   
/// A builder for [`RevokeSecurityGroupEgressInput`](crate::operation::revoke_security_group_egress::RevokeSecurityGroupEgressInput).
  346    345   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  347    346   
#[non_exhaustive]

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

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

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