AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045 (ignoring whitespace)

Files changed:

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

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

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

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

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

@@ -67,67 +160,160 @@
   87     87   
    "com.amazonaws.ec2.synthetic",
   88     88   
    "DescribePlacementGroupsInput",
   89     89   
);
   90     90   
static DESCRIBEPLACEMENTGROUPSINPUT_MEMBER_GROUP_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.ec2.synthetic#DescribePlacementGroupsInput$GroupIds",
   93     93   
        "com.amazonaws.ec2.synthetic",
   94     94   
        "DescribePlacementGroupsInput",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::List,
   97         -
    "group_ids",
          97  +
    "GroupIds",
   98     98   
    0,
   99     99   
)
  100    100   
.with_xml_name("GroupId");
  101    101   
static DESCRIBEPLACEMENTGROUPSINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.ec2.synthetic#DescribePlacementGroupsInput$DryRun",
  104    104   
        "com.amazonaws.ec2.synthetic",
  105    105   
        "DescribePlacementGroupsInput",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::Boolean,
  108         -
    "dry_run",
         108  +
    "DryRun",
  109    109   
    1,
  110    110   
)
  111    111   
.with_xml_name("dryRun");
  112    112   
static DESCRIBEPLACEMENTGROUPSINPUT_MEMBER_GROUP_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.ec2.synthetic#DescribePlacementGroupsInput$GroupNames",
  115    115   
        "com.amazonaws.ec2.synthetic",
  116    116   
        "DescribePlacementGroupsInput",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::List,
  119         -
    "group_names",
         119  +
    "GroupNames",
  120    120   
    2,
  121    121   
)
  122    122   
.with_xml_name("groupName");
  123    123   
static DESCRIBEPLACEMENTGROUPSINPUT_MEMBER_FILTERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.ec2.synthetic#DescribePlacementGroupsInput$Filters",
  126    126   
        "com.amazonaws.ec2.synthetic",
  127    127   
        "DescribePlacementGroupsInput",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::List,
  130         -
    "filters",
         130  +
    "Filters",
  131    131   
    3,
  132    132   
)
  133    133   
.with_xml_name("Filter");
  134    134   
static DESCRIBEPLACEMENTGROUPSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  135    135   
    DESCRIBEPLACEMENTGROUPSINPUT_SCHEMA_ID,
  136    136   
    ::aws_smithy_schema::ShapeType::Structure,
  137    137   
    &[
  138    138   
        &DESCRIBEPLACEMENTGROUPSINPUT_MEMBER_GROUP_IDS,
  139    139   
        &DESCRIBEPLACEMENTGROUPSINPUT_MEMBER_DRY_RUN,
  140    140   
        &DESCRIBEPLACEMENTGROUPSINPUT_MEMBER_GROUP_NAMES,
@@ -165,165 +289,277 @@
  185    185   
                    }
  186    186   
                    Ok(())
  187    187   
                },
  188    188   
            )?;
  189    189   
        }
  190    190   
        Ok(())
  191    191   
    }
  192    192   
}
  193    193   
impl DescribePlacementGroupsInput {
  194    194   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  195         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  196         -
        deserializer: &mut D,
         195  +
    pub fn deserialize(
         196  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  197    197   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  198    198   
        #[allow(unused_variables, unused_mut)]
  199    199   
        let mut builder = Self::builder();
  200    200   
        #[allow(
  201    201   
            unused_variables,
  202    202   
            unreachable_code,
  203    203   
            clippy::single_match,
  204    204   
            clippy::match_single_binding,
  205    205   
            clippy::diverging_sub_expression
  206    206   
        )]
  207         -
        deserializer.read_struct(&DESCRIBEPLACEMENTGROUPSINPUT_SCHEMA, (), |_, member, deser| {
         207  +
        deserializer.read_struct(&DESCRIBEPLACEMENTGROUPSINPUT_SCHEMA, &mut |member, deser| {
  208    208   
            match member.member_index() {
  209    209   
                Some(0) => {
  210         -
                    builder.group_ids = Some({
  211         -
                        let container = if let Some(cap) = deser.container_size() {
  212         -
                            Vec::with_capacity(cap)
  213         -
                        } else {
  214         -
                            Vec::new()
  215         -
                        };
  216         -
                        deser.read_list(member, container, |mut list, deser| {
  217         -
                            list.push(deser.read_string(member)?);
  218         -
                            Ok(list)
  219         -
                        })?
  220         -
                    });
         210  +
                    builder.group_ids = Some(deser.read_string_list(member)?);
  221    211   
                }
  222    212   
                Some(1) => {
  223    213   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  224    214   
                }
  225    215   
                Some(2) => {
  226         -
                    builder.group_names = Some({
  227         -
                        let container = if let Some(cap) = deser.container_size() {
  228         -
                            Vec::with_capacity(cap)
  229         -
                        } else {
  230         -
                            Vec::new()
  231         -
                        };
  232         -
                        deser.read_list(member, container, |mut list, deser| {
  233         -
                            list.push(deser.read_string(member)?);
  234         -
                            Ok(list)
  235         -
                        })?
  236         -
                    });
         216  +
                    builder.group_names = Some(deser.read_string_list(member)?);
  237    217   
                }
  238    218   
                Some(3) => {
  239    219   
                    builder.filters = Some({
  240         -
                        let container = if let Some(cap) = deser.container_size() {
  241         -
                            Vec::with_capacity(cap)
  242         -
                        } else {
  243         -
                            Vec::new()
  244         -
                        };
  245         -
                        deser.read_list(member, container, |mut list, deser| {
  246         -
                            list.push(crate::types::Filter::deserialize(deser)?);
  247         -
                            Ok(list)
  248         -
                        })?
         220  +
                        let mut container = Vec::new();
         221  +
                        deser.read_list(member, &mut |deser| {
         222  +
                            container.push(crate::types::Filter::deserialize(deser)?);
         223  +
                            Ok(())
         224  +
                        })?;
         225  +
                        container
  249    226   
                    });
  250    227   
                }
  251    228   
                _ => {}
  252    229   
            }
  253    230   
            Ok(())
  254    231   
        })?;
  255    232   
        builder
  256    233   
            .build()
  257    234   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  258    235   
    }
  259    236   
}
         237  +
impl DescribePlacementGroupsInput {
         238  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         239  +
    pub fn deserialize_with_response(
         240  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         241  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         242  +
        _status: u16,
         243  +
        _body: &[u8],
         244  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         245  +
        Self::deserialize(deserializer)
         246  +
    }
         247  +
}
  260    248   
impl DescribePlacementGroupsInput {
  261    249   
    /// Creates a new builder-style object to manufacture [`DescribePlacementGroupsInput`](crate::operation::describe_placement_groups::DescribePlacementGroupsInput).
  262    250   
    pub fn builder() -> crate::operation::describe_placement_groups::builders::DescribePlacementGroupsInputBuilder {
  263    251   
        crate::operation::describe_placement_groups::builders::DescribePlacementGroupsInputBuilder::default()
  264    252   
    }
  265    253   
}
  266    254   
  267    255   
/// A builder for [`DescribePlacementGroupsInput`](crate::operation::describe_placement_groups::DescribePlacementGroupsInput).
  268    256   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  269    257   
#[non_exhaustive]

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

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/describe_prefix_lists.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 `DescribePrefixLists`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct DescribePrefixLists;
    6      6   
impl DescribePrefixLists {
    7      7   
    /// Creates a new `DescribePrefixLists`
    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::describe_prefix_lists::DescribePrefixListsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::describe_prefix_lists::DescribePrefixListsOutput::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::describe_prefix_lists::DescribePrefixListsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::describe_prefix_lists::DescribePrefixListsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::describe_prefix_lists::DescribePrefixListsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -118,122 +180,185 @@
  138    142   
                crate::operation::describe_prefix_lists::DescribePrefixListsError,
  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 DescribePrefixListsResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DescribePrefixListsResponseDeserializer {
  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_describe_prefix_lists::de_describe_prefix_lists_http_error(status, headers, body)
  160    165   
        } else {

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

@@ -37,37 +256,254 @@
   57     57   
    "com.amazonaws.ec2.synthetic",
   58     58   
    "DescribePrefixListsInput",
   59     59   
);
   60     60   
static DESCRIBEPREFIXLISTSINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.ec2.synthetic#DescribePrefixListsInput$DryRun",
   63     63   
        "com.amazonaws.ec2.synthetic",
   64     64   
        "DescribePrefixListsInput",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::Boolean,
   67         -
    "dry_run",
          67  +
    "DryRun",
   68     68   
    0,
   69     69   
);
   70     70   
static DESCRIBEPREFIXLISTSINPUT_MEMBER_FILTERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.ec2.synthetic#DescribePrefixListsInput$Filters",
   73     73   
        "com.amazonaws.ec2.synthetic",
   74     74   
        "DescribePrefixListsInput",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::List,
   77         -
    "filters",
          77  +
    "Filters",
   78     78   
    1,
   79     79   
)
   80     80   
.with_xml_name("Filter");
   81     81   
static DESCRIBEPREFIXLISTSINPUT_MEMBER_MAX_RESULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.ec2.synthetic#DescribePrefixListsInput$MaxResults",
   84     84   
        "com.amazonaws.ec2.synthetic",
   85     85   
        "DescribePrefixListsInput",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::Integer,
   88         -
    "max_results",
          88  +
    "MaxResults",
   89     89   
    2,
   90     90   
);
   91     91   
static DESCRIBEPREFIXLISTSINPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.ec2.synthetic#DescribePrefixListsInput$NextToken",
   94     94   
        "com.amazonaws.ec2.synthetic",
   95     95   
        "DescribePrefixListsInput",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::String,
   98         -
    "next_token",
          98  +
    "NextToken",
   99     99   
    3,
  100    100   
);
  101    101   
static DESCRIBEPREFIXLISTSINPUT_MEMBER_PREFIX_LIST_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.ec2.synthetic#DescribePrefixListsInput$PrefixListIds",
  104    104   
        "com.amazonaws.ec2.synthetic",
  105    105   
        "DescribePrefixListsInput",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::List,
  108         -
    "prefix_list_ids",
         108  +
    "PrefixListIds",
  109    109   
    4,
  110    110   
)
  111    111   
.with_xml_name("PrefixListId");
  112    112   
static DESCRIBEPREFIXLISTSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  113    113   
    DESCRIBEPREFIXLISTSINPUT_SCHEMA_ID,
  114    114   
    ::aws_smithy_schema::ShapeType::Structure,
  115    115   
    &[
  116    116   
        &DESCRIBEPREFIXLISTSINPUT_MEMBER_DRY_RUN,
  117    117   
        &DESCRIBEPREFIXLISTSINPUT_MEMBER_FILTERS,
  118    118   
        &DESCRIBEPREFIXLISTSINPUT_MEMBER_MAX_RESULTS,
  119    119   
        &DESCRIBEPREFIXLISTSINPUT_MEMBER_NEXT_TOKEN,
  120    120   
        &DESCRIBEPREFIXLISTSINPUT_MEMBER_PREFIX_LIST_IDS,
  121    121   
    ],
  122    122   
);
  123    123   
impl DescribePrefixListsInput {
  124    124   
    /// The schema for this shape.
  125    125   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DESCRIBEPREFIXLISTSINPUT_SCHEMA;
  126    126   
}
  127    127   
impl ::aws_smithy_schema::serde::SerializableStruct for DescribePrefixListsInput {
  128    128   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  129    129   
    fn serialize_members(
  130    130   
        &self,
  131    131   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  132    132   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  133    133   
        if let Some(ref val) = self.dry_run {
  134    134   
            ser.write_boolean(&DESCRIBEPREFIXLISTSINPUT_MEMBER_DRY_RUN, *val)?;
  135    135   
        }
  136    136   
        if let Some(ref val) = self.filters {
  137    137   
            ser.write_list(
  138    138   
                &DESCRIBEPREFIXLISTSINPUT_MEMBER_FILTERS,
  139    139   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  140    140   
                    for item in val {
  141    141   
                        ser.write_struct(crate::types::Filter::SCHEMA, item)?;
  142    142   
                    }
  143    143   
                    Ok(())
  144    144   
                },
  145    145   
            )?;
  146    146   
        }
  147    147   
        if let Some(ref val) = self.max_results {
  148    148   
            ser.write_integer(&DESCRIBEPREFIXLISTSINPUT_MEMBER_MAX_RESULTS, *val)?;
  149    149   
        }
  150    150   
        if let Some(ref val) = self.next_token {
  151    151   
            ser.write_string(&DESCRIBEPREFIXLISTSINPUT_MEMBER_NEXT_TOKEN, val)?;
  152    152   
        }
  153    153   
        if let Some(ref val) = self.prefix_list_ids {
  154    154   
            ser.write_list(
  155    155   
                &DESCRIBEPREFIXLISTSINPUT_MEMBER_PREFIX_LIST_IDS,
  156    156   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  157    157   
                    for item in val {
  158    158   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  159    159   
                    }
  160    160   
                    Ok(())
  161    161   
                },
  162    162   
            )?;
  163    163   
        }
  164    164   
        Ok(())
  165    165   
    }
  166    166   
}
  167    167   
impl DescribePrefixListsInput {
  168    168   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  169         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  170         -
        deserializer: &mut D,
         169  +
    pub fn deserialize(
         170  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  171    171   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  172    172   
        #[allow(unused_variables, unused_mut)]
  173    173   
        let mut builder = Self::builder();
  174    174   
        #[allow(
  175    175   
            unused_variables,
  176    176   
            unreachable_code,
  177    177   
            clippy::single_match,
  178    178   
            clippy::match_single_binding,
  179    179   
            clippy::diverging_sub_expression
  180    180   
        )]
  181         -
        deserializer.read_struct(&DESCRIBEPREFIXLISTSINPUT_SCHEMA, (), |_, member, deser| {
         181  +
        deserializer.read_struct(&DESCRIBEPREFIXLISTSINPUT_SCHEMA, &mut |member, deser| {
  182    182   
            match member.member_index() {
  183    183   
                Some(0) => {
  184    184   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  185    185   
                }
  186    186   
                Some(1) => {
  187    187   
                    builder.filters = Some({
  188         -
                        let container = if let Some(cap) = deser.container_size() {
  189         -
                            Vec::with_capacity(cap)
  190         -
                        } else {
  191         -
                            Vec::new()
  192         -
                        };
  193         -
                        deser.read_list(member, container, |mut list, deser| {
  194         -
                            list.push(crate::types::Filter::deserialize(deser)?);
  195         -
                            Ok(list)
  196         -
                        })?
         188  +
                        let mut container = Vec::new();
         189  +
                        deser.read_list(member, &mut |deser| {
         190  +
                            container.push(crate::types::Filter::deserialize(deser)?);
         191  +
                            Ok(())
         192  +
                        })?;
         193  +
                        container
  197    194   
                    });
  198    195   
                }
  199    196   
                Some(2) => {
  200    197   
                    builder.max_results = Some(deser.read_integer(member)?);
  201    198   
                }
  202    199   
                Some(3) => {
  203    200   
                    builder.next_token = Some(deser.read_string(member)?);
  204    201   
                }
  205    202   
                Some(4) => {
  206         -
                    builder.prefix_list_ids = Some({
  207         -
                        let container = if let Some(cap) = deser.container_size() {
  208         -
                            Vec::with_capacity(cap)
  209         -
                        } else {
  210         -
                            Vec::new()
  211         -
                        };
  212         -
                        deser.read_list(member, container, |mut list, deser| {
  213         -
                            list.push(deser.read_string(member)?);
  214         -
                            Ok(list)
  215         -
                        })?
  216         -
                    });
         203  +
                    builder.prefix_list_ids = Some(deser.read_string_list(member)?);
  217    204   
                }
  218    205   
                _ => {}
  219    206   
            }
  220    207   
            Ok(())
  221    208   
        })?;
  222    209   
        builder
  223    210   
            .build()
  224    211   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  225    212   
    }
  226    213   
}
         214  +
impl DescribePrefixListsInput {
         215  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         216  +
    pub fn deserialize_with_response(
         217  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         218  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         219  +
        _status: u16,
         220  +
        _body: &[u8],
         221  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         222  +
        Self::deserialize(deserializer)
         223  +
    }
         224  +
}
  227    225   
impl DescribePrefixListsInput {
  228    226   
    /// Creates a new builder-style object to manufacture [`DescribePrefixListsInput`](crate::operation::describe_prefix_lists::DescribePrefixListsInput).
  229    227   
    pub fn builder() -> crate::operation::describe_prefix_lists::builders::DescribePrefixListsInputBuilder {
  230    228   
        crate::operation::describe_prefix_lists::builders::DescribePrefixListsInputBuilder::default()
  231    229   
    }
  232    230   
}
  233    231   
  234    232   
/// A builder for [`DescribePrefixListsInput`](crate::operation::describe_prefix_lists::DescribePrefixListsInput).
  235    233   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  236    234   
#[non_exhaustive]

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

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/describe_principal_id_format.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 `DescribePrincipalIdFormat`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct DescribePrincipalIdFormat;
    6      6   
impl DescribePrincipalIdFormat {
    7      7   
    /// Creates a new `DescribePrincipalIdFormat`
    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::describe_principal_id_format::DescribePrincipalIdFormatInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::describe_principal_id_format::DescribePrincipalIdFormatOutput::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::describe_principal_id_format::DescribePrincipalIdFormatInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::describe_principal_id_format::DescribePrincipalIdFormatOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::describe_principal_id_format::DescribePrincipalIdFormatError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -118,124 +180,187 @@
  138    144   
                crate::operation::describe_principal_id_format::DescribePrincipalIdFormatError,
  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 DescribePrincipalIdFormatResponseDeserializer;
  147    153   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DescribePrincipalIdFormatResponseDeserializer {
  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_describe_principal_id_format::de_describe_principal_id_format_http_error(status, headers, body)
  160    167   
        } else {

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

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

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

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

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

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

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

@@ -43,43 +245,243 @@
   63     63   
    "com.amazonaws.ec2.synthetic",
   64     64   
    "DescribePublicIpv4PoolsInput",
   65     65   
);
   66     66   
static DESCRIBEPUBLICIPV4POOLSINPUT_MEMBER_POOL_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "com.amazonaws.ec2.synthetic#DescribePublicIpv4PoolsInput$PoolIds",
   69     69   
        "com.amazonaws.ec2.synthetic",
   70     70   
        "DescribePublicIpv4PoolsInput",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::List,
   73         -
    "pool_ids",
          73  +
    "PoolIds",
   74     74   
    0,
   75     75   
)
   76     76   
.with_xml_name("PoolId");
   77     77   
static DESCRIBEPUBLICIPV4POOLSINPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.ec2.synthetic#DescribePublicIpv4PoolsInput$NextToken",
   80     80   
        "com.amazonaws.ec2.synthetic",
   81     81   
        "DescribePublicIpv4PoolsInput",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "next_token",
          84  +
    "NextToken",
   85     85   
    1,
   86     86   
);
   87     87   
static DESCRIBEPUBLICIPV4POOLSINPUT_MEMBER_MAX_RESULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static(
   89     89   
        "com.amazonaws.ec2.synthetic#DescribePublicIpv4PoolsInput$MaxResults",
   90     90   
        "com.amazonaws.ec2.synthetic",
   91     91   
        "DescribePublicIpv4PoolsInput",
   92     92   
    ),
   93     93   
    ::aws_smithy_schema::ShapeType::Integer,
   94         -
    "max_results",
          94  +
    "MaxResults",
   95     95   
    2,
   96     96   
);
   97     97   
static DESCRIBEPUBLICIPV4POOLSINPUT_MEMBER_FILTERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.ec2.synthetic#DescribePublicIpv4PoolsInput$Filters",
  100    100   
        "com.amazonaws.ec2.synthetic",
  101    101   
        "DescribePublicIpv4PoolsInput",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::List,
  104         -
    "filters",
         104  +
    "Filters",
  105    105   
    3,
  106    106   
)
  107    107   
.with_xml_name("Filter");
  108    108   
static DESCRIBEPUBLICIPV4POOLSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  109    109   
    DESCRIBEPUBLICIPV4POOLSINPUT_SCHEMA_ID,
  110    110   
    ::aws_smithy_schema::ShapeType::Structure,
  111    111   
    &[
  112    112   
        &DESCRIBEPUBLICIPV4POOLSINPUT_MEMBER_POOL_IDS,
  113    113   
        &DESCRIBEPUBLICIPV4POOLSINPUT_MEMBER_NEXT_TOKEN,
  114    114   
        &DESCRIBEPUBLICIPV4POOLSINPUT_MEMBER_MAX_RESULTS,
  115    115   
        &DESCRIBEPUBLICIPV4POOLSINPUT_MEMBER_FILTERS,
  116    116   
    ],
  117    117   
);
  118    118   
impl DescribePublicIpv4PoolsInput {
  119    119   
    /// The schema for this shape.
  120    120   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DESCRIBEPUBLICIPV4POOLSINPUT_SCHEMA;
  121    121   
}
  122    122   
impl ::aws_smithy_schema::serde::SerializableStruct for DescribePublicIpv4PoolsInput {
  123    123   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  124    124   
    fn serialize_members(
  125    125   
        &self,
  126    126   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  127    127   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  128    128   
        if let Some(ref val) = self.pool_ids {
  129    129   
            ser.write_list(
  130    130   
                &DESCRIBEPUBLICIPV4POOLSINPUT_MEMBER_POOL_IDS,
  131    131   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  132    132   
                    for item in val {
  133    133   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  134    134   
                    }
  135    135   
                    Ok(())
  136    136   
                },
  137    137   
            )?;
  138    138   
        }
  139    139   
        if let Some(ref val) = self.next_token {
  140    140   
            ser.write_string(&DESCRIBEPUBLICIPV4POOLSINPUT_MEMBER_NEXT_TOKEN, val)?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.max_results {
  143    143   
            ser.write_integer(&DESCRIBEPUBLICIPV4POOLSINPUT_MEMBER_MAX_RESULTS, *val)?;
  144    144   
        }
  145    145   
        if let Some(ref val) = self.filters {
  146    146   
            ser.write_list(
  147    147   
                &DESCRIBEPUBLICIPV4POOLSINPUT_MEMBER_FILTERS,
  148    148   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  149    149   
                    for item in val {
  150    150   
                        ser.write_struct(crate::types::Filter::SCHEMA, item)?;
  151    151   
                    }
  152    152   
                    Ok(())
  153    153   
                },
  154    154   
            )?;
  155    155   
        }
  156    156   
        Ok(())
  157    157   
    }
  158    158   
}
  159    159   
impl DescribePublicIpv4PoolsInput {
  160    160   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  161         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  162         -
        deserializer: &mut D,
         161  +
    pub fn deserialize(
         162  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  163    163   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  164    164   
        #[allow(unused_variables, unused_mut)]
  165    165   
        let mut builder = Self::builder();
  166    166   
        #[allow(
  167    167   
            unused_variables,
  168    168   
            unreachable_code,
  169    169   
            clippy::single_match,
  170    170   
            clippy::match_single_binding,
  171    171   
            clippy::diverging_sub_expression
  172    172   
        )]
  173         -
        deserializer.read_struct(&DESCRIBEPUBLICIPV4POOLSINPUT_SCHEMA, (), |_, member, deser| {
         173  +
        deserializer.read_struct(&DESCRIBEPUBLICIPV4POOLSINPUT_SCHEMA, &mut |member, deser| {
  174    174   
            match member.member_index() {
  175    175   
                Some(0) => {
  176         -
                    builder.pool_ids = Some({
  177         -
                        let container = if let Some(cap) = deser.container_size() {
  178         -
                            Vec::with_capacity(cap)
  179         -
                        } else {
  180         -
                            Vec::new()
  181         -
                        };
  182         -
                        deser.read_list(member, container, |mut list, deser| {
  183         -
                            list.push(deser.read_string(member)?);
  184         -
                            Ok(list)
  185         -
                        })?
  186         -
                    });
         176  +
                    builder.pool_ids = Some(deser.read_string_list(member)?);
  187    177   
                }
  188    178   
                Some(1) => {
  189    179   
                    builder.next_token = Some(deser.read_string(member)?);
  190    180   
                }
  191    181   
                Some(2) => {
  192    182   
                    builder.max_results = Some(deser.read_integer(member)?);
  193    183   
                }
  194    184   
                Some(3) => {
  195    185   
                    builder.filters = Some({
  196         -
                        let container = if let Some(cap) = deser.container_size() {
  197         -
                            Vec::with_capacity(cap)
  198         -
                        } else {
  199         -
                            Vec::new()
  200         -
                        };
  201         -
                        deser.read_list(member, container, |mut list, deser| {
  202         -
                            list.push(crate::types::Filter::deserialize(deser)?);
  203         -
                            Ok(list)
  204         -
                        })?
         186  +
                        let mut container = Vec::new();
         187  +
                        deser.read_list(member, &mut |deser| {
         188  +
                            container.push(crate::types::Filter::deserialize(deser)?);
         189  +
                            Ok(())
         190  +
                        })?;
         191  +
                        container
  205    192   
                    });
  206    193   
                }
  207    194   
                _ => {}
  208    195   
            }
  209    196   
            Ok(())
  210    197   
        })?;
  211    198   
        builder
  212    199   
            .build()
  213    200   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  214    201   
    }
  215    202   
}
         203  +
impl DescribePublicIpv4PoolsInput {
         204  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         205  +
    pub fn deserialize_with_response(
         206  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         207  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         208  +
        _status: u16,
         209  +
        _body: &[u8],
         210  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         211  +
        Self::deserialize(deserializer)
         212  +
    }
         213  +
}
  216    214   
impl DescribePublicIpv4PoolsInput {
  217    215   
    /// Creates a new builder-style object to manufacture [`DescribePublicIpv4PoolsInput`](crate::operation::describe_public_ipv4_pools::DescribePublicIpv4PoolsInput).
  218    216   
    pub fn builder() -> crate::operation::describe_public_ipv4_pools::builders::DescribePublicIpv4PoolsInputBuilder {
  219    217   
        crate::operation::describe_public_ipv4_pools::builders::DescribePublicIpv4PoolsInputBuilder::default()
  220    218   
    }
  221    219   
}
  222    220   
  223    221   
/// A builder for [`DescribePublicIpv4PoolsInput`](crate::operation::describe_public_ipv4_pools::DescribePublicIpv4PoolsInput).
  224    222   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  225    223   
#[non_exhaustive]

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

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

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

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

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

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

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