AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

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

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

@@ -79,79 +298,296 @@
   99     99   
    "com.amazonaws.ec2.synthetic",
  100    100   
    "DescribeVpcEndpointsInput",
  101    101   
);
  102    102   
static DESCRIBEVPCENDPOINTSINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static(
  104    104   
        "com.amazonaws.ec2.synthetic#DescribeVpcEndpointsInput$DryRun",
  105    105   
        "com.amazonaws.ec2.synthetic",
  106    106   
        "DescribeVpcEndpointsInput",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::Boolean,
  109         -
    "dry_run",
         109  +
    "DryRun",
  110    110   
    0,
  111    111   
);
  112    112   
static DESCRIBEVPCENDPOINTSINPUT_MEMBER_VPC_ENDPOINT_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.ec2.synthetic#DescribeVpcEndpointsInput$VpcEndpointIds",
  115    115   
        "com.amazonaws.ec2.synthetic",
  116    116   
        "DescribeVpcEndpointsInput",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::List,
  119         -
    "vpc_endpoint_ids",
         119  +
    "VpcEndpointIds",
  120    120   
    1,
  121    121   
)
  122    122   
.with_xml_name("VpcEndpointId");
  123    123   
static DESCRIBEVPCENDPOINTSINPUT_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#DescribeVpcEndpointsInput$Filters",
  126    126   
        "com.amazonaws.ec2.synthetic",
  127    127   
        "DescribeVpcEndpointsInput",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::List,
  130         -
    "filters",
         130  +
    "Filters",
  131    131   
    2,
  132    132   
)
  133    133   
.with_xml_name("Filter");
  134    134   
static DESCRIBEVPCENDPOINTSINPUT_MEMBER_MAX_RESULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "com.amazonaws.ec2.synthetic#DescribeVpcEndpointsInput$MaxResults",
  137    137   
        "com.amazonaws.ec2.synthetic",
  138    138   
        "DescribeVpcEndpointsInput",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::Integer,
  141         -
    "max_results",
         141  +
    "MaxResults",
  142    142   
    3,
  143    143   
);
  144    144   
static DESCRIBEVPCENDPOINTSINPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "com.amazonaws.ec2.synthetic#DescribeVpcEndpointsInput$NextToken",
  147    147   
        "com.amazonaws.ec2.synthetic",
  148    148   
        "DescribeVpcEndpointsInput",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::String,
  151         -
    "next_token",
         151  +
    "NextToken",
  152    152   
    4,
  153    153   
);
  154    154   
static DESCRIBEVPCENDPOINTSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  155    155   
    DESCRIBEVPCENDPOINTSINPUT_SCHEMA_ID,
  156    156   
    ::aws_smithy_schema::ShapeType::Structure,
  157    157   
    &[
  158    158   
        &DESCRIBEVPCENDPOINTSINPUT_MEMBER_DRY_RUN,
  159    159   
        &DESCRIBEVPCENDPOINTSINPUT_MEMBER_VPC_ENDPOINT_IDS,
  160    160   
        &DESCRIBEVPCENDPOINTSINPUT_MEMBER_FILTERS,
  161    161   
        &DESCRIBEVPCENDPOINTSINPUT_MEMBER_MAX_RESULTS,
  162    162   
        &DESCRIBEVPCENDPOINTSINPUT_MEMBER_NEXT_TOKEN,
  163    163   
    ],
  164    164   
);
  165    165   
impl DescribeVpcEndpointsInput {
  166    166   
    /// The schema for this shape.
  167    167   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DESCRIBEVPCENDPOINTSINPUT_SCHEMA;
  168    168   
}
  169    169   
impl ::aws_smithy_schema::serde::SerializableStruct for DescribeVpcEndpointsInput {
  170    170   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  171    171   
    fn serialize_members(
  172    172   
        &self,
  173    173   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  174    174   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  175    175   
        if let Some(ref val) = self.dry_run {
  176    176   
            ser.write_boolean(&DESCRIBEVPCENDPOINTSINPUT_MEMBER_DRY_RUN, *val)?;
  177    177   
        }
  178    178   
        if let Some(ref val) = self.vpc_endpoint_ids {
  179    179   
            ser.write_list(
  180    180   
                &DESCRIBEVPCENDPOINTSINPUT_MEMBER_VPC_ENDPOINT_IDS,
  181    181   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  182    182   
                    for item in val {
  183    183   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  184    184   
                    }
  185    185   
                    Ok(())
  186    186   
                },
  187    187   
            )?;
  188    188   
        }
  189    189   
        if let Some(ref val) = self.filters {
  190    190   
            ser.write_list(
  191    191   
                &DESCRIBEVPCENDPOINTSINPUT_MEMBER_FILTERS,
  192    192   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  193    193   
                    for item in val {
  194    194   
                        ser.write_struct(crate::types::Filter::SCHEMA, item)?;
  195    195   
                    }
  196    196   
                    Ok(())
  197    197   
                },
  198    198   
            )?;
  199    199   
        }
  200    200   
        if let Some(ref val) = self.max_results {
  201    201   
            ser.write_integer(&DESCRIBEVPCENDPOINTSINPUT_MEMBER_MAX_RESULTS, *val)?;
  202    202   
        }
  203    203   
        if let Some(ref val) = self.next_token {
  204    204   
            ser.write_string(&DESCRIBEVPCENDPOINTSINPUT_MEMBER_NEXT_TOKEN, val)?;
  205    205   
        }
  206    206   
        Ok(())
  207    207   
    }
  208    208   
}
  209    209   
impl DescribeVpcEndpointsInput {
  210    210   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  211         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  212         -
        deserializer: &mut D,
         211  +
    pub fn deserialize(
         212  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  213    213   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  214    214   
        #[allow(unused_variables, unused_mut)]
  215    215   
        let mut builder = Self::builder();
  216    216   
        #[allow(
  217    217   
            unused_variables,
  218    218   
            unreachable_code,
  219    219   
            clippy::single_match,
  220    220   
            clippy::match_single_binding,
  221    221   
            clippy::diverging_sub_expression
  222    222   
        )]
  223         -
        deserializer.read_struct(&DESCRIBEVPCENDPOINTSINPUT_SCHEMA, (), |_, member, deser| {
         223  +
        deserializer.read_struct(&DESCRIBEVPCENDPOINTSINPUT_SCHEMA, &mut |member, deser| {
  224    224   
            match member.member_index() {
  225    225   
                Some(0) => {
  226    226   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  227    227   
                }
  228    228   
                Some(1) => {
  229         -
                    builder.vpc_endpoint_ids = Some({
  230         -
                        let container = if let Some(cap) = deser.container_size() {
  231         -
                            Vec::with_capacity(cap)
  232         -
                        } else {
  233         -
                            Vec::new()
  234         -
                        };
  235         -
                        deser.read_list(member, container, |mut list, deser| {
  236         -
                            list.push(deser.read_string(member)?);
  237         -
                            Ok(list)
  238         -
                        })?
  239         -
                    });
         229  +
                    builder.vpc_endpoint_ids = Some(deser.read_string_list(member)?);
  240    230   
                }
  241    231   
                Some(2) => {
  242    232   
                    builder.filters = Some({
  243         -
                        let container = if let Some(cap) = deser.container_size() {
  244         -
                            Vec::with_capacity(cap)
  245         -
                        } else {
  246         -
                            Vec::new()
  247         -
                        };
  248         -
                        deser.read_list(member, container, |mut list, deser| {
  249         -
                            list.push(crate::types::Filter::deserialize(deser)?);
  250         -
                            Ok(list)
  251         -
                        })?
         233  +
                        let mut container = Vec::new();
         234  +
                        deser.read_list(member, &mut |deser| {
         235  +
                            container.push(crate::types::Filter::deserialize(deser)?);
         236  +
                            Ok(())
         237  +
                        })?;
         238  +
                        container
  252    239   
                    });
  253    240   
                }
  254    241   
                Some(3) => {
  255    242   
                    builder.max_results = Some(deser.read_integer(member)?);
  256    243   
                }
  257    244   
                Some(4) => {
  258    245   
                    builder.next_token = Some(deser.read_string(member)?);
  259    246   
                }
  260    247   
                _ => {}
  261    248   
            }
  262    249   
            Ok(())
  263    250   
        })?;
  264    251   
        builder
  265    252   
            .build()
  266    253   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  267    254   
    }
  268    255   
}
         256  +
impl DescribeVpcEndpointsInput {
         257  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         258  +
    pub fn deserialize_with_response(
         259  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         260  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         261  +
        _status: u16,
         262  +
        _body: &[u8],
         263  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         264  +
        Self::deserialize(deserializer)
         265  +
    }
         266  +
}
  269    267   
impl DescribeVpcEndpointsInput {
  270    268   
    /// Creates a new builder-style object to manufacture [`DescribeVpcEndpointsInput`](crate::operation::describe_vpc_endpoints::DescribeVpcEndpointsInput).
  271    269   
    pub fn builder() -> crate::operation::describe_vpc_endpoints::builders::DescribeVpcEndpointsInputBuilder {
  272    270   
        crate::operation::describe_vpc_endpoints::builders::DescribeVpcEndpointsInputBuilder::default()
  273    271   
    }
  274    272   
}
  275    273   
  276    274   
/// A builder for [`DescribeVpcEndpointsInput`](crate::operation::describe_vpc_endpoints::DescribeVpcEndpointsInput).
  277    275   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  278    276   
#[non_exhaustive]

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

@@ -6,6 +142,194 @@
   26     26   
    "com.amazonaws.ec2.synthetic",
   27     27   
    "DescribeVpcEndpointsOutput",
   28     28   
);
   29     29   
static DESCRIBEVPCENDPOINTSOUTPUT_MEMBER_VPC_ENDPOINTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static(
   31     31   
        "com.amazonaws.ec2.synthetic#DescribeVpcEndpointsOutput$VpcEndpoints",
   32     32   
        "com.amazonaws.ec2.synthetic",
   33     33   
        "DescribeVpcEndpointsOutput",
   34     34   
    ),
   35     35   
    ::aws_smithy_schema::ShapeType::List,
   36         -
    "vpc_endpoints",
          36  +
    "VpcEndpoints",
   37     37   
    0,
   38     38   
)
   39     39   
.with_xml_name("vpcEndpointSet");
   40     40   
static DESCRIBEVPCENDPOINTSOUTPUT_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#DescribeVpcEndpointsOutput$NextToken",
   43     43   
        "com.amazonaws.ec2.synthetic",
   44     44   
        "DescribeVpcEndpointsOutput",
   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 DESCRIBEVPCENDPOINTSOUTPUT_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 DESCRIBEVPCENDPOINTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   52     59   
    DESCRIBEVPCENDPOINTSOUTPUT_SCHEMA_ID,
   53     60   
    ::aws_smithy_schema::ShapeType::Structure,
   54     61   
    &[
   55     62   
        &DESCRIBEVPCENDPOINTSOUTPUT_MEMBER_VPC_ENDPOINTS,
   56     63   
        &DESCRIBEVPCENDPOINTSOUTPUT_MEMBER_NEXT_TOKEN,
          64  +
        &DESCRIBEVPCENDPOINTSOUTPUT_MEMBER__REQUEST_ID,
   57     65   
    ],
   58     66   
);
   59     67   
impl DescribeVpcEndpointsOutput {
   60     68   
    /// The schema for this shape.
   61     69   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DESCRIBEVPCENDPOINTSOUTPUT_SCHEMA;
   62     70   
}
   63     71   
impl ::aws_smithy_schema::serde::SerializableStruct for DescribeVpcEndpointsOutput {
   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.vpc_endpoints {
   70     78   
            ser.write_list(
   71     79   
                &DESCRIBEVPCENDPOINTSOUTPUT_MEMBER_VPC_ENDPOINTS,
   72     80   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   73     81   
                    for item in val {
   74     82   
                        ser.write_struct(crate::types::VpcEndpoint::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(&DESCRIBEVPCENDPOINTSOUTPUT_MEMBER_NEXT_TOKEN, val)?;
   82     90   
        }
   83     91   
        Ok(())
   84     92   
    }
   85     93   
}
   86     94   
impl DescribeVpcEndpointsOutput {
   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(&DESCRIBEVPCENDPOINTSOUTPUT_SCHEMA, &mut |member, deser| {
         109  +
            match member.member_index() {
         110  +
                Some(0) => {
         111  +
                    builder.vpc_endpoints = Some({
         112  +
                        let mut container = Vec::new();
         113  +
                        deser.read_list(member, &mut |deser| {
         114  +
                            container.push(crate::types::VpcEndpoint::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 DescribeVpcEndpointsOutput {
         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(&DESCRIBEVPCENDPOINTSOUTPUT_SCHEMA, (), |_, member, deser| {
         155  +
        deserializer.read_struct(&DESCRIBEVPCENDPOINTSOUTPUT_SCHEMA, &mut |member, deser| {
  101    156   
            match member.member_index() {
  102    157   
                Some(0) => {
  103    158   
                    builder.vpc_endpoints = 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::VpcEndpoint::deserialize(deser)?);
  111         -
                            Ok(list)
  112         -
                        })?
         159  +
                        let mut container = Vec::new();
         160  +
                        deser.read_list(member, &mut |deser| {
         161  +
                            container.push(crate::types::VpcEndpoint::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_vpc_peering_connections.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 `DescribeVpcPeeringConnections`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct DescribeVpcPeeringConnections;
    6      6   
impl DescribeVpcPeeringConnections {
    7      7   
    /// Creates a new `DescribeVpcPeeringConnections`
    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_vpc_peering_connections::DescribeVpcPeeringConnectionsInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::describe_vpc_peering_connections::DescribeVpcPeeringConnectionsOutput::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_vpc_peering_connections::DescribeVpcPeeringConnectionsInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::describe_vpc_peering_connections::DescribeVpcPeeringConnectionsOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::describe_vpc_peering_connections::DescribeVpcPeeringConnectionsError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -118,124 +180,187 @@
  138    144   
                crate::operation::describe_vpc_peering_connections::DescribeVpcPeeringConnectionsError,
  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 DescribeVpcPeeringConnectionsResponseDeserializer;
  147    153   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DescribeVpcPeeringConnectionsResponseDeserializer {
  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_vpc_peering_connections::de_describe_vpc_peering_connections_http_error(status, headers, body)
  160    167   
        } else {

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

@@ -79,79 +299,297 @@
   99     99   
    "com.amazonaws.ec2.synthetic",
  100    100   
    "DescribeVpcPeeringConnectionsInput",
  101    101   
);
  102    102   
static DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static(
  104    104   
        "com.amazonaws.ec2.synthetic#DescribeVpcPeeringConnectionsInput$NextToken",
  105    105   
        "com.amazonaws.ec2.synthetic",
  106    106   
        "DescribeVpcPeeringConnectionsInput",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "next_token",
         109  +
    "NextToken",
  110    110   
    0,
  111    111   
);
  112    112   
static DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_MAX_RESULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.ec2.synthetic#DescribeVpcPeeringConnectionsInput$MaxResults",
  115    115   
        "com.amazonaws.ec2.synthetic",
  116    116   
        "DescribeVpcPeeringConnectionsInput",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::Integer,
  119         -
    "max_results",
         119  +
    "MaxResults",
  120    120   
    1,
  121    121   
);
  122    122   
static DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  123    123   
    ::aws_smithy_schema::ShapeId::from_static(
  124    124   
        "com.amazonaws.ec2.synthetic#DescribeVpcPeeringConnectionsInput$DryRun",
  125    125   
        "com.amazonaws.ec2.synthetic",
  126    126   
        "DescribeVpcPeeringConnectionsInput",
  127    127   
    ),
  128    128   
    ::aws_smithy_schema::ShapeType::Boolean,
  129         -
    "dry_run",
         129  +
    "DryRun",
  130    130   
    2,
  131    131   
)
  132    132   
.with_xml_name("dryRun");
  133    133   
static DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_VPC_PEERING_CONNECTION_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  134    134   
    ::aws_smithy_schema::ShapeId::from_static(
  135    135   
        "com.amazonaws.ec2.synthetic#DescribeVpcPeeringConnectionsInput$VpcPeeringConnectionIds",
  136    136   
        "com.amazonaws.ec2.synthetic",
  137    137   
        "DescribeVpcPeeringConnectionsInput",
  138    138   
    ),
  139    139   
    ::aws_smithy_schema::ShapeType::List,
  140         -
    "vpc_peering_connection_ids",
         140  +
    "VpcPeeringConnectionIds",
  141    141   
    3,
  142    142   
)
  143    143   
.with_xml_name("VpcPeeringConnectionId");
  144    144   
static DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_FILTERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "com.amazonaws.ec2.synthetic#DescribeVpcPeeringConnectionsInput$Filters",
  147    147   
        "com.amazonaws.ec2.synthetic",
  148    148   
        "DescribeVpcPeeringConnectionsInput",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::List,
  151         -
    "filters",
         151  +
    "Filters",
  152    152   
    4,
  153    153   
)
  154    154   
.with_xml_name("Filter");
  155    155   
static DESCRIBEVPCPEERINGCONNECTIONSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  156    156   
    DESCRIBEVPCPEERINGCONNECTIONSINPUT_SCHEMA_ID,
  157    157   
    ::aws_smithy_schema::ShapeType::Structure,
  158    158   
    &[
  159    159   
        &DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_NEXT_TOKEN,
  160    160   
        &DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_MAX_RESULTS,
  161    161   
        &DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_DRY_RUN,
  162    162   
        &DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_VPC_PEERING_CONNECTION_IDS,
  163    163   
        &DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_FILTERS,
  164    164   
    ],
  165    165   
);
  166    166   
impl DescribeVpcPeeringConnectionsInput {
  167    167   
    /// The schema for this shape.
  168    168   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DESCRIBEVPCPEERINGCONNECTIONSINPUT_SCHEMA;
  169    169   
}
  170    170   
impl ::aws_smithy_schema::serde::SerializableStruct for DescribeVpcPeeringConnectionsInput {
  171    171   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  172    172   
    fn serialize_members(
  173    173   
        &self,
  174    174   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  175    175   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  176    176   
        if let Some(ref val) = self.next_token {
  177    177   
            ser.write_string(&DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_NEXT_TOKEN, val)?;
  178    178   
        }
  179    179   
        if let Some(ref val) = self.max_results {
  180    180   
            ser.write_integer(&DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_MAX_RESULTS, *val)?;
  181    181   
        }
  182    182   
        if let Some(ref val) = self.dry_run {
  183    183   
            ser.write_boolean(&DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_DRY_RUN, *val)?;
  184    184   
        }
  185    185   
        if let Some(ref val) = self.vpc_peering_connection_ids {
  186    186   
            ser.write_list(
  187    187   
                &DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_VPC_PEERING_CONNECTION_IDS,
  188    188   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  189    189   
                    for item in val {
  190    190   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  191    191   
                    }
  192    192   
                    Ok(())
  193    193   
                },
  194    194   
            )?;
  195    195   
        }
  196    196   
        if let Some(ref val) = self.filters {
  197    197   
            ser.write_list(
  198    198   
                &DESCRIBEVPCPEERINGCONNECTIONSINPUT_MEMBER_FILTERS,
  199    199   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  200    200   
                    for item in val {
  201    201   
                        ser.write_struct(crate::types::Filter::SCHEMA, item)?;
  202    202   
                    }
  203    203   
                    Ok(())
  204    204   
                },
  205    205   
            )?;
  206    206   
        }
  207    207   
        Ok(())
  208    208   
    }
  209    209   
}
  210    210   
impl DescribeVpcPeeringConnectionsInput {
  211    211   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  212         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  213         -
        deserializer: &mut D,
         212  +
    pub fn deserialize(
         213  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  214    214   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  215    215   
        #[allow(unused_variables, unused_mut)]
  216    216   
        let mut builder = Self::builder();
  217    217   
        #[allow(
  218    218   
            unused_variables,
  219    219   
            unreachable_code,
  220    220   
            clippy::single_match,
  221    221   
            clippy::match_single_binding,
  222    222   
            clippy::diverging_sub_expression
  223    223   
        )]
  224         -
        deserializer.read_struct(&DESCRIBEVPCPEERINGCONNECTIONSINPUT_SCHEMA, (), |_, member, deser| {
         224  +
        deserializer.read_struct(&DESCRIBEVPCPEERINGCONNECTIONSINPUT_SCHEMA, &mut |member, deser| {
  225    225   
            match member.member_index() {
  226    226   
                Some(0) => {
  227    227   
                    builder.next_token = Some(deser.read_string(member)?);
  228    228   
                }
  229    229   
                Some(1) => {
  230    230   
                    builder.max_results = Some(deser.read_integer(member)?);
  231    231   
                }
  232    232   
                Some(2) => {
  233    233   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  234    234   
                }
  235    235   
                Some(3) => {
  236         -
                    builder.vpc_peering_connection_ids = Some({
  237         -
                        let container = if let Some(cap) = deser.container_size() {
  238         -
                            Vec::with_capacity(cap)
  239         -
                        } else {
  240         -
                            Vec::new()
  241         -
                        };
  242         -
                        deser.read_list(member, container, |mut list, deser| {
  243         -
                            list.push(deser.read_string(member)?);
  244         -
                            Ok(list)
  245         -
                        })?
  246         -
                    });
         236  +
                    builder.vpc_peering_connection_ids = Some(deser.read_string_list(member)?);
  247    237   
                }
  248    238   
                Some(4) => {
  249    239   
                    builder.filters = Some({
  250         -
                        let container = if let Some(cap) = deser.container_size() {
  251         -
                            Vec::with_capacity(cap)
  252         -
                        } else {
  253         -
                            Vec::new()
  254         -
                        };
  255         -
                        deser.read_list(member, container, |mut list, deser| {
  256         -
                            list.push(crate::types::Filter::deserialize(deser)?);
  257         -
                            Ok(list)
  258         -
                        })?
         240  +
                        let mut container = Vec::new();
         241  +
                        deser.read_list(member, &mut |deser| {
         242  +
                            container.push(crate::types::Filter::deserialize(deser)?);
         243  +
                            Ok(())
         244  +
                        })?;
         245  +
                        container
  259    246   
                    });
  260    247   
                }
  261    248   
                _ => {}
  262    249   
            }
  263    250   
            Ok(())
  264    251   
        })?;
  265    252   
        builder
  266    253   
            .build()
  267    254   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  268    255   
    }
  269    256   
}
         257  +
impl DescribeVpcPeeringConnectionsInput {
         258  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         259  +
    pub fn deserialize_with_response(
         260  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         261  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         262  +
        _status: u16,
         263  +
        _body: &[u8],
         264  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         265  +
        Self::deserialize(deserializer)
         266  +
    }
         267  +
}
  270    268   
impl DescribeVpcPeeringConnectionsInput {
  271    269   
    /// Creates a new builder-style object to manufacture [`DescribeVpcPeeringConnectionsInput`](crate::operation::describe_vpc_peering_connections::DescribeVpcPeeringConnectionsInput).
  272    270   
    pub fn builder() -> crate::operation::describe_vpc_peering_connections::builders::DescribeVpcPeeringConnectionsInputBuilder {
  273    271   
        crate::operation::describe_vpc_peering_connections::builders::DescribeVpcPeeringConnectionsInputBuilder::default()
  274    272   
    }
  275    273   
}
  276    274   
  277    275   
/// A builder for [`DescribeVpcPeeringConnectionsInput`](crate::operation::describe_vpc_peering_connections::DescribeVpcPeeringConnectionsInput).
  278    276   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  279    277   
#[non_exhaustive]

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

@@ -6,6 +142,194 @@
   26     26   
    "com.amazonaws.ec2.synthetic",
   27     27   
    "DescribeVpcPeeringConnectionsOutput",
   28     28   
);
   29     29   
static DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_MEMBER_VPC_PEERING_CONNECTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static(
   31     31   
        "com.amazonaws.ec2.synthetic#DescribeVpcPeeringConnectionsOutput$VpcPeeringConnections",
   32     32   
        "com.amazonaws.ec2.synthetic",
   33     33   
        "DescribeVpcPeeringConnectionsOutput",
   34     34   
    ),
   35     35   
    ::aws_smithy_schema::ShapeType::List,
   36         -
    "vpc_peering_connections",
          36  +
    "VpcPeeringConnections",
   37     37   
    0,
   38     38   
)
   39     39   
.with_xml_name("vpcPeeringConnectionSet");
   40     40   
static DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_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#DescribeVpcPeeringConnectionsOutput$NextToken",
   43     43   
        "com.amazonaws.ec2.synthetic",
   44     44   
        "DescribeVpcPeeringConnectionsOutput",
   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 DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_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 DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   52     59   
    DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_SCHEMA_ID,
   53     60   
    ::aws_smithy_schema::ShapeType::Structure,
   54     61   
    &[
   55     62   
        &DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_MEMBER_VPC_PEERING_CONNECTIONS,
   56     63   
        &DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_MEMBER_NEXT_TOKEN,
          64  +
        &DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_MEMBER__REQUEST_ID,
   57     65   
    ],
   58     66   
);
   59     67   
impl DescribeVpcPeeringConnectionsOutput {
   60     68   
    /// The schema for this shape.
   61     69   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_SCHEMA;
   62     70   
}
   63     71   
impl ::aws_smithy_schema::serde::SerializableStruct for DescribeVpcPeeringConnectionsOutput {
   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.vpc_peering_connections {
   70     78   
            ser.write_list(
   71     79   
                &DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_MEMBER_VPC_PEERING_CONNECTIONS,
   72     80   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   73     81   
                    for item in val {
   74     82   
                        ser.write_struct(crate::types::VpcPeeringConnection::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(&DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_MEMBER_NEXT_TOKEN, val)?;
   82     90   
        }
   83     91   
        Ok(())
   84     92   
    }
   85     93   
}
   86     94   
impl DescribeVpcPeeringConnectionsOutput {
   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(&DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_SCHEMA, &mut |member, deser| {
         109  +
            match member.member_index() {
         110  +
                Some(0) => {
         111  +
                    builder.vpc_peering_connections = Some({
         112  +
                        let mut container = Vec::new();
         113  +
                        deser.read_list(member, &mut |deser| {
         114  +
                            container.push(crate::types::VpcPeeringConnection::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 DescribeVpcPeeringConnectionsOutput {
         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(&DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_SCHEMA, (), |_, member, deser| {
         155  +
        deserializer.read_struct(&DESCRIBEVPCPEERINGCONNECTIONSOUTPUT_SCHEMA, &mut |member, deser| {
  101    156   
            match member.member_index() {
  102    157   
                Some(0) => {
  103    158   
                    builder.vpc_peering_connections = 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::VpcPeeringConnection::deserialize(deser)?);
  111         -
                            Ok(list)
  112         -
                        })?
         159  +
                        let mut container = Vec::new();
         160  +
                        deser.read_list(member, &mut |deser| {
         161  +
                            container.push(crate::types::VpcPeeringConnection::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_vpcs.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 `DescribeVpcs`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct DescribeVpcs;
    6      6   
impl DescribeVpcs {
    7      7   
    /// Creates a new `DescribeVpcs`
    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_vpcs::DescribeVpcsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::describe_vpcs::DescribeVpcsOutput::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_vpcs::DescribeVpcsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::describe_vpcs::DescribeVpcsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::describe_vpcs::DescribeVpcsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -115,119 +177,182 @@
  135    139   
                crate::operation::describe_vpcs::DescribeVpcsError,
  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 DescribeVpcsResponseDeserializer;
  144    148   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DescribeVpcsResponseDeserializer {
  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_vpcs::de_describe_vpcs_http_error(status, headers, body)
  157    162   
        } else {

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

@@ -89,89 +309,307 @@
  109    109   
    "com.amazonaws.ec2.synthetic",
  110    110   
    "DescribeVpcsInput",
  111    111   
);
  112    112   
static DESCRIBEVPCSINPUT_MEMBER_FILTERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.ec2.synthetic#DescribeVpcsInput$Filters",
  115    115   
        "com.amazonaws.ec2.synthetic",
  116    116   
        "DescribeVpcsInput",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::List,
  119         -
    "filters",
         119  +
    "Filters",
  120    120   
    0,
  121    121   
)
  122    122   
.with_xml_name("Filter");
  123    123   
static DESCRIBEVPCSINPUT_MEMBER_VPC_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.ec2.synthetic#DescribeVpcsInput$VpcIds",
  126    126   
        "com.amazonaws.ec2.synthetic",
  127    127   
        "DescribeVpcsInput",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::List,
  130         -
    "vpc_ids",
         130  +
    "VpcIds",
  131    131   
    1,
  132    132   
)
  133    133   
.with_xml_name("VpcId");
  134    134   
static DESCRIBEVPCSINPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "com.amazonaws.ec2.synthetic#DescribeVpcsInput$NextToken",
  137    137   
        "com.amazonaws.ec2.synthetic",
  138    138   
        "DescribeVpcsInput",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::String,
  141         -
    "next_token",
         141  +
    "NextToken",
  142    142   
    2,
  143    143   
);
  144    144   
static DESCRIBEVPCSINPUT_MEMBER_MAX_RESULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "com.amazonaws.ec2.synthetic#DescribeVpcsInput$MaxResults",
  147    147   
        "com.amazonaws.ec2.synthetic",
  148    148   
        "DescribeVpcsInput",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::Integer,
  151         -
    "max_results",
         151  +
    "MaxResults",
  152    152   
    3,
  153    153   
);
  154    154   
static DESCRIBEVPCSINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  155    155   
    ::aws_smithy_schema::ShapeId::from_static(
  156    156   
        "com.amazonaws.ec2.synthetic#DescribeVpcsInput$DryRun",
  157    157   
        "com.amazonaws.ec2.synthetic",
  158    158   
        "DescribeVpcsInput",
  159    159   
    ),
  160    160   
    ::aws_smithy_schema::ShapeType::Boolean,
  161         -
    "dry_run",
         161  +
    "DryRun",
  162    162   
    4,
  163    163   
)
  164    164   
.with_xml_name("dryRun");
  165    165   
static DESCRIBEVPCSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  166    166   
    DESCRIBEVPCSINPUT_SCHEMA_ID,
  167    167   
    ::aws_smithy_schema::ShapeType::Structure,
  168    168   
    &[
  169    169   
        &DESCRIBEVPCSINPUT_MEMBER_FILTERS,
  170    170   
        &DESCRIBEVPCSINPUT_MEMBER_VPC_IDS,
  171    171   
        &DESCRIBEVPCSINPUT_MEMBER_NEXT_TOKEN,
  172    172   
        &DESCRIBEVPCSINPUT_MEMBER_MAX_RESULTS,
  173    173   
        &DESCRIBEVPCSINPUT_MEMBER_DRY_RUN,
  174    174   
    ],
  175    175   
);
  176    176   
impl DescribeVpcsInput {
  177    177   
    /// The schema for this shape.
  178    178   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DESCRIBEVPCSINPUT_SCHEMA;
  179    179   
}
  180    180   
impl ::aws_smithy_schema::serde::SerializableStruct for DescribeVpcsInput {
  181    181   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  182    182   
    fn serialize_members(
  183    183   
        &self,
  184    184   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  185    185   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  186    186   
        if let Some(ref val) = self.filters {
  187    187   
            ser.write_list(
  188    188   
                &DESCRIBEVPCSINPUT_MEMBER_FILTERS,
  189    189   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  190    190   
                    for item in val {
  191    191   
                        ser.write_struct(crate::types::Filter::SCHEMA, item)?;
  192    192   
                    }
  193    193   
                    Ok(())
  194    194   
                },
  195    195   
            )?;
  196    196   
        }
  197    197   
        if let Some(ref val) = self.vpc_ids {
  198    198   
            ser.write_list(
  199    199   
                &DESCRIBEVPCSINPUT_MEMBER_VPC_IDS,
  200    200   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  201    201   
                    for item in val {
  202    202   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  203    203   
                    }
  204    204   
                    Ok(())
  205    205   
                },
  206    206   
            )?;
  207    207   
        }
  208    208   
        if let Some(ref val) = self.next_token {
  209    209   
            ser.write_string(&DESCRIBEVPCSINPUT_MEMBER_NEXT_TOKEN, val)?;
  210    210   
        }
  211    211   
        if let Some(ref val) = self.max_results {
  212    212   
            ser.write_integer(&DESCRIBEVPCSINPUT_MEMBER_MAX_RESULTS, *val)?;
  213    213   
        }
  214    214   
        if let Some(ref val) = self.dry_run {
  215    215   
            ser.write_boolean(&DESCRIBEVPCSINPUT_MEMBER_DRY_RUN, *val)?;
  216    216   
        }
  217    217   
        Ok(())
  218    218   
    }
  219    219   
}
  220    220   
impl DescribeVpcsInput {
  221    221   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  222         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  223         -
        deserializer: &mut D,
         222  +
    pub fn deserialize(
         223  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  224    224   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  225    225   
        #[allow(unused_variables, unused_mut)]
  226    226   
        let mut builder = Self::builder();
  227    227   
        #[allow(
  228    228   
            unused_variables,
  229    229   
            unreachable_code,
  230    230   
            clippy::single_match,
  231    231   
            clippy::match_single_binding,
  232    232   
            clippy::diverging_sub_expression
  233    233   
        )]
  234         -
        deserializer.read_struct(&DESCRIBEVPCSINPUT_SCHEMA, (), |_, member, deser| {
         234  +
        deserializer.read_struct(&DESCRIBEVPCSINPUT_SCHEMA, &mut |member, deser| {
  235    235   
            match member.member_index() {
  236    236   
                Some(0) => {
  237    237   
                    builder.filters = Some({
  238         -
                        let container = if let Some(cap) = deser.container_size() {
  239         -
                            Vec::with_capacity(cap)
  240         -
                        } else {
  241         -
                            Vec::new()
  242         -
                        };
  243         -
                        deser.read_list(member, container, |mut list, deser| {
  244         -
                            list.push(crate::types::Filter::deserialize(deser)?);
  245         -
                            Ok(list)
  246         -
                        })?
         238  +
                        let mut container = Vec::new();
         239  +
                        deser.read_list(member, &mut |deser| {
         240  +
                            container.push(crate::types::Filter::deserialize(deser)?);
         241  +
                            Ok(())
         242  +
                        })?;
         243  +
                        container
  247    244   
                    });
  248    245   
                }
  249    246   
                Some(1) => {
  250         -
                    builder.vpc_ids = Some({
  251         -
                        let container = if let Some(cap) = deser.container_size() {
  252         -
                            Vec::with_capacity(cap)
  253         -
                        } else {
  254         -
                            Vec::new()
  255         -
                        };
  256         -
                        deser.read_list(member, container, |mut list, deser| {
  257         -
                            list.push(deser.read_string(member)?);
  258         -
                            Ok(list)
  259         -
                        })?
  260         -
                    });
         247  +
                    builder.vpc_ids = Some(deser.read_string_list(member)?);
  261    248   
                }
  262    249   
                Some(2) => {
  263    250   
                    builder.next_token = Some(deser.read_string(member)?);
  264    251   
                }
  265    252   
                Some(3) => {
  266    253   
                    builder.max_results = Some(deser.read_integer(member)?);
  267    254   
                }
  268    255   
                Some(4) => {
  269    256   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  270    257   
                }
  271    258   
                _ => {}
  272    259   
            }
  273    260   
            Ok(())
  274    261   
        })?;
  275    262   
        builder
  276    263   
            .build()
  277    264   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  278    265   
    }
  279    266   
}
         267  +
impl DescribeVpcsInput {
         268  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         269  +
    pub fn deserialize_with_response(
         270  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         271  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         272  +
        _status: u16,
         273  +
        _body: &[u8],
         274  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         275  +
        Self::deserialize(deserializer)
         276  +
    }
         277  +
}
  280    278   
impl DescribeVpcsInput {
  281    279   
    /// Creates a new builder-style object to manufacture [`DescribeVpcsInput`](crate::operation::describe_vpcs::DescribeVpcsInput).
  282    280   
    pub fn builder() -> crate::operation::describe_vpcs::builders::DescribeVpcsInputBuilder {
  283    281   
        crate::operation::describe_vpcs::builders::DescribeVpcsInputBuilder::default()
  284    282   
    }
  285    283   
}
  286    284   
  287    285   
/// A builder for [`DescribeVpcsInput`](crate::operation::describe_vpcs::DescribeVpcsInput).
  288    286   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  289    287   
#[non_exhaustive]

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

@@ -6,6 +142,197 @@
   26     26   
    "com.amazonaws.ec2.synthetic",
   27     27   
    "DescribeVpcsOutput",
   28     28   
);
   29     29   
static DESCRIBEVPCSOUTPUT_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#DescribeVpcsOutput$NextToken",
   32     32   
        "com.amazonaws.ec2.synthetic",
   33     33   
        "DescribeVpcsOutput",
   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 DESCRIBEVPCSOUTPUT_MEMBER_VPCS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.ec2.synthetic#DescribeVpcsOutput$Vpcs",
   43     43   
        "com.amazonaws.ec2.synthetic",
   44     44   
        "DescribeVpcsOutput",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::List,
   47         -
    "vpcs",
          47  +
    "Vpcs",
   48     48   
    1,
   49     49   
)
   50     50   
.with_xml_name("vpcSet");
          51  +
static DESCRIBEVPCSOUTPUT_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 DESCRIBEVPCSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   52     59   
    DESCRIBEVPCSOUTPUT_SCHEMA_ID,
   53     60   
    ::aws_smithy_schema::ShapeType::Structure,
   54         -
    &[&DESCRIBEVPCSOUTPUT_MEMBER_NEXT_TOKEN, &DESCRIBEVPCSOUTPUT_MEMBER_VPCS],
          61  +
    &[
          62  +
        &DESCRIBEVPCSOUTPUT_MEMBER_NEXT_TOKEN,
          63  +
        &DESCRIBEVPCSOUTPUT_MEMBER_VPCS,
          64  +
        &DESCRIBEVPCSOUTPUT_MEMBER__REQUEST_ID,
          65  +
    ],
   55     66   
);
   56     67   
impl DescribeVpcsOutput {
   57     68   
    /// The schema for this shape.
   58     69   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DESCRIBEVPCSOUTPUT_SCHEMA;
   59     70   
}
   60     71   
impl ::aws_smithy_schema::serde::SerializableStruct for DescribeVpcsOutput {
   61     72   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   62     73   
    fn serialize_members(
   63     74   
        &self,
   64     75   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   65     76   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   66     77   
        if let Some(ref val) = self.next_token {
   67     78   
            ser.write_string(&DESCRIBEVPCSOUTPUT_MEMBER_NEXT_TOKEN, val)?;
   68     79   
        }
   69     80   
        if let Some(ref val) = self.vpcs {
   70     81   
            ser.write_list(
   71     82   
                &DESCRIBEVPCSOUTPUT_MEMBER_VPCS,
   72     83   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   73     84   
                    for item in val {
   74     85   
                        ser.write_struct(crate::types::Vpc::SCHEMA, item)?;
   75     86   
                    }
   76     87   
                    Ok(())
   77     88   
                },
   78     89   
            )?;
   79     90   
        }
   80     91   
        Ok(())
   81     92   
    }
   82     93   
}
   83     94   
impl DescribeVpcsOutput {
   84     95   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   85         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   86         -
        deserializer: &mut D,
          96  +
    pub fn deserialize(
          97  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   87     98   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   88     99   
        #[allow(unused_variables, unused_mut)]
   89    100   
        let mut builder = Self::builder();
   90    101   
        #[allow(
   91    102   
            unused_variables,
   92    103   
            unreachable_code,
   93    104   
            clippy::single_match,
   94    105   
            clippy::match_single_binding,
   95    106   
            clippy::diverging_sub_expression
   96    107   
        )]
   97         -
        deserializer.read_struct(&DESCRIBEVPCSOUTPUT_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&DESCRIBEVPCSOUTPUT_SCHEMA, &mut |member, deser| {
   98    109   
            match member.member_index() {
   99    110   
                Some(0) => {
  100    111   
                    builder.next_token = Some(deser.read_string(member)?);
  101    112   
                }
  102    113   
                Some(1) => {
  103    114   
                    builder.vpcs = 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::Vpc::deserialize(deser)?);
  111         -
                            Ok(list)
  112         -
                        })?
         115  +
                        let mut container = Vec::new();
         116  +
                        deser.read_list(member, &mut |deser| {
         117  +
                            container.push(crate::types::Vpc::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 DescribeVpcsOutput {
         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],
         142  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         143  +
        #[allow(unused_variables, unused_mut)]
         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  +
        }
         148  +
        #[allow(
         149  +
            unused_variables,
         150  +
            unreachable_code,
         151  +
            clippy::single_match,
         152  +
            clippy::match_single_binding,
         153  +
            clippy::diverging_sub_expression
         154  +
        )]
         155  +
        deserializer.read_struct(&DESCRIBEVPCSOUTPUT_SCHEMA, &mut |member, deser| {
         156  +
            match member.member_index() {
         157  +
                Some(0) => {
         158  +
                    builder.next_token = Some(deser.read_string(member)?);
         159  +
                }
         160  +
                Some(1) => {
         161  +
                    builder.vpcs = Some({
         162  +
                        let mut container = Vec::new();
         163  +
                        deser.read_list(member, &mut |deser| {
         164  +
                            container.push(crate::types::Vpc::deserialize(deser)?);
         165  +
                            Ok(())
         166  +
                        })?;
         167  +
                        container
  113    168   
                    });
  114    169   
                }
  115    170   
                _ => {}
  116    171   
            }
  117    172   
            Ok(())
  118    173   
        })?;
  119    174   
        Ok(builder.build())
  120    175   
    }
  121    176   
}
  122    177   
impl ::aws_types::request_id::RequestId for DescribeVpcsOutput {

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

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

@@ -80,80 +266,264 @@
  100    100   
    "com.amazonaws.ec2.synthetic",
  101    101   
    "DescribeVpnConnectionsInput",
  102    102   
);
  103    103   
static DESCRIBEVPNCONNECTIONSINPUT_MEMBER_FILTERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.ec2.synthetic#DescribeVpnConnectionsInput$Filters",
  106    106   
        "com.amazonaws.ec2.synthetic",
  107    107   
        "DescribeVpnConnectionsInput",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::List,
  110         -
    "filters",
         110  +
    "Filters",
  111    111   
    0,
  112    112   
)
  113    113   
.with_xml_name("Filter");
  114    114   
static DESCRIBEVPNCONNECTIONSINPUT_MEMBER_VPN_CONNECTION_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "com.amazonaws.ec2.synthetic#DescribeVpnConnectionsInput$VpnConnectionIds",
  117    117   
        "com.amazonaws.ec2.synthetic",
  118    118   
        "DescribeVpnConnectionsInput",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::List,
  121         -
    "vpn_connection_ids",
         121  +
    "VpnConnectionIds",
  122    122   
    1,
  123    123   
)
  124    124   
.with_xml_name("VpnConnectionId");
  125    125   
static DESCRIBEVPNCONNECTIONSINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "com.amazonaws.ec2.synthetic#DescribeVpnConnectionsInput$DryRun",
  128    128   
        "com.amazonaws.ec2.synthetic",
  129    129   
        "DescribeVpnConnectionsInput",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::Boolean,
  132         -
    "dry_run",
         132  +
    "DryRun",
  133    133   
    2,
  134    134   
)
  135    135   
.with_xml_name("dryRun");
  136    136   
static DESCRIBEVPNCONNECTIONSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  137    137   
    DESCRIBEVPNCONNECTIONSINPUT_SCHEMA_ID,
  138    138   
    ::aws_smithy_schema::ShapeType::Structure,
  139    139   
    &[
  140    140   
        &DESCRIBEVPNCONNECTIONSINPUT_MEMBER_FILTERS,
  141    141   
        &DESCRIBEVPNCONNECTIONSINPUT_MEMBER_VPN_CONNECTION_IDS,
  142    142   
        &DESCRIBEVPNCONNECTIONSINPUT_MEMBER_DRY_RUN,
  143    143   
    ],
  144    144   
);
  145    145   
impl DescribeVpnConnectionsInput {
  146    146   
    /// The schema for this shape.
  147    147   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DESCRIBEVPNCONNECTIONSINPUT_SCHEMA;
  148    148   
}
  149    149   
impl ::aws_smithy_schema::serde::SerializableStruct for DescribeVpnConnectionsInput {
  150    150   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  151    151   
    fn serialize_members(
  152    152   
        &self,
  153    153   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  154    154   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  155    155   
        if let Some(ref val) = self.filters {
  156    156   
            ser.write_list(
  157    157   
                &DESCRIBEVPNCONNECTIONSINPUT_MEMBER_FILTERS,
  158    158   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  159    159   
                    for item in val {
  160    160   
                        ser.write_struct(crate::types::Filter::SCHEMA, item)?;
  161    161   
                    }
  162    162   
                    Ok(())
  163    163   
                },
  164    164   
            )?;
  165    165   
        }
  166    166   
        if let Some(ref val) = self.vpn_connection_ids {
  167    167   
            ser.write_list(
  168    168   
                &DESCRIBEVPNCONNECTIONSINPUT_MEMBER_VPN_CONNECTION_IDS,
  169    169   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  170    170   
                    for item in val {
  171    171   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  172    172   
                    }
  173    173   
                    Ok(())
  174    174   
                },
  175    175   
            )?;
  176    176   
        }
  177    177   
        if let Some(ref val) = self.dry_run {
  178    178   
            ser.write_boolean(&DESCRIBEVPNCONNECTIONSINPUT_MEMBER_DRY_RUN, *val)?;
  179    179   
        }
  180    180   
        Ok(())
  181    181   
    }
  182    182   
}
  183    183   
impl DescribeVpnConnectionsInput {
  184    184   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  185         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  186         -
        deserializer: &mut D,
         185  +
    pub fn deserialize(
         186  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  187    187   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  188    188   
        #[allow(unused_variables, unused_mut)]
  189    189   
        let mut builder = Self::builder();
  190    190   
        #[allow(
  191    191   
            unused_variables,
  192    192   
            unreachable_code,
  193    193   
            clippy::single_match,
  194    194   
            clippy::match_single_binding,
  195    195   
            clippy::diverging_sub_expression
  196    196   
        )]
  197         -
        deserializer.read_struct(&DESCRIBEVPNCONNECTIONSINPUT_SCHEMA, (), |_, member, deser| {
         197  +
        deserializer.read_struct(&DESCRIBEVPNCONNECTIONSINPUT_SCHEMA, &mut |member, deser| {
  198    198   
            match member.member_index() {
  199    199   
                Some(0) => {
  200    200   
                    builder.filters = Some({
  201         -
                        let container = if let Some(cap) = deser.container_size() {
  202         -
                            Vec::with_capacity(cap)
  203         -
                        } else {
  204         -
                            Vec::new()
  205         -
                        };
  206         -
                        deser.read_list(member, container, |mut list, deser| {
  207         -
                            list.push(crate::types::Filter::deserialize(deser)?);
  208         -
                            Ok(list)
  209         -
                        })?
         201  +
                        let mut container = Vec::new();
         202  +
                        deser.read_list(member, &mut |deser| {
         203  +
                            container.push(crate::types::Filter::deserialize(deser)?);
         204  +
                            Ok(())
         205  +
                        })?;
         206  +
                        container
  210    207   
                    });
  211    208   
                }
  212    209   
                Some(1) => {
  213         -
                    builder.vpn_connection_ids = Some({
  214         -
                        let container = if let Some(cap) = deser.container_size() {
  215         -
                            Vec::with_capacity(cap)
  216         -
                        } else {
  217         -
                            Vec::new()
  218         -
                        };
  219         -
                        deser.read_list(member, container, |mut list, deser| {
  220         -
                            list.push(deser.read_string(member)?);
  221         -
                            Ok(list)
  222         -
                        })?
  223         -
                    });
         210  +
                    builder.vpn_connection_ids = Some(deser.read_string_list(member)?);
  224    211   
                }
  225    212   
                Some(2) => {
  226    213   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  227    214   
                }
  228    215   
                _ => {}
  229    216   
            }
  230    217   
            Ok(())
  231    218   
        })?;
  232    219   
        builder
  233    220   
            .build()
  234    221   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  235    222   
    }
  236    223   
}
         224  +
impl DescribeVpnConnectionsInput {
         225  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         226  +
    pub fn deserialize_with_response(
         227  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         228  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         229  +
        _status: u16,
         230  +
        _body: &[u8],
         231  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         232  +
        Self::deserialize(deserializer)
         233  +
    }
         234  +
}
  237    235   
impl DescribeVpnConnectionsInput {
  238    236   
    /// Creates a new builder-style object to manufacture [`DescribeVpnConnectionsInput`](crate::operation::describe_vpn_connections::DescribeVpnConnectionsInput).
  239    237   
    pub fn builder() -> crate::operation::describe_vpn_connections::builders::DescribeVpnConnectionsInputBuilder {
  240    238   
        crate::operation::describe_vpn_connections::builders::DescribeVpnConnectionsInputBuilder::default()
  241    239   
    }
  242    240   
}
  243    241   
  244    242   
/// A builder for [`DescribeVpnConnectionsInput`](crate::operation::describe_vpn_connections::DescribeVpnConnectionsInput).
  245    243   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  246    244   
#[non_exhaustive]

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

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

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

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

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

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

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

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