AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_bucket_inventory_configurations/_list_bucket_inventory_configurations_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_bucket_metrics_configurations.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 `ListBucketMetricsConfigurations`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ListBucketMetricsConfigurations;
    6      6   
impl ListBucketMetricsConfigurations {
    7      7   
    /// Creates a new `ListBucketMetricsConfigurations`
    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::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsOutput::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::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -132,138 +194,201 @@
  152    158   
                .build(),
  153    159   
            );
  154    160   
  155    161   
        ::std::borrow::Cow::Owned(rcb)
  156    162   
    }
  157    163   
}
  158    164   
  159    165   
#[derive(Debug)]
  160    166   
struct ListBucketMetricsConfigurationsResponseDeserializer;
  161    167   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListBucketMetricsConfigurationsResponseDeserializer {
  162         -
    fn deserialize_nonstreaming(
         168  +
    fn deserialize_nonstreaming_with_config(
  163    169   
        &self,
  164    170   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         171  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  165    172   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  166    173   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  167    174   
        let headers = response.headers();
  168    175   
        let body = response.body().bytes().expect("body loaded");
  169    176   
        #[allow(unused_mut)]
  170    177   
        let mut force_error = false;
  171    178   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  172    179   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  173    180   
            force_error = true;
  174    181   
        }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_bucket_metrics_configurations/_list_bucket_metrics_configurations_input.rs

@@ -9,9 +154,200 @@
   29     29   
    "com.amazonaws.s3.synthetic",
   30     30   
    "ListBucketMetricsConfigurationsInput",
   31     31   
);
   32     32   
static LISTBUCKETMETRICSCONFIGURATIONSINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static(
   34     34   
        "com.amazonaws.s3.synthetic#ListBucketMetricsConfigurationsInput$Bucket",
   35     35   
        "com.amazonaws.s3.synthetic",
   36     36   
        "ListBucketMetricsConfigurationsInput",
   37     37   
    ),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "bucket",
          39  +
    "Bucket",
   40     40   
    0,
   41     41   
)
   42     42   
.with_http_label();
   43     43   
static LISTBUCKETMETRICSCONFIGURATIONSINPUT_MEMBER_CONTINUATION_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.s3.synthetic#ListBucketMetricsConfigurationsInput$ContinuationToken",
   46     46   
        "com.amazonaws.s3.synthetic",
   47     47   
        "ListBucketMetricsConfigurationsInput",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "continuation_token",
          50  +
    "ContinuationToken",
   51     51   
    1,
   52     52   
)
   53     53   
.with_http_query("continuation-token");
   54     54   
static LISTBUCKETMETRICSCONFIGURATIONSINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static(
   56     56   
        "com.amazonaws.s3.synthetic#ListBucketMetricsConfigurationsInput$ExpectedBucketOwner",
   57     57   
        "com.amazonaws.s3.synthetic",
   58     58   
        "ListBucketMetricsConfigurationsInput",
   59     59   
    ),
   60     60   
    ::aws_smithy_schema::ShapeType::String,
   61         -
    "expected_bucket_owner",
          61  +
    "ExpectedBucketOwner",
   62     62   
    2,
   63     63   
)
   64     64   
.with_http_header("x-amz-expected-bucket-owner");
   65     65   
static LISTBUCKETMETRICSCONFIGURATIONSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   66     66   
    LISTBUCKETMETRICSCONFIGURATIONSINPUT_SCHEMA_ID,
   67     67   
    ::aws_smithy_schema::ShapeType::Structure,
   68     68   
    &[
   69     69   
        &LISTBUCKETMETRICSCONFIGURATIONSINPUT_MEMBER_BUCKET,
   70     70   
        &LISTBUCKETMETRICSCONFIGURATIONSINPUT_MEMBER_CONTINUATION_TOKEN,
   71     71   
        &LISTBUCKETMETRICSCONFIGURATIONSINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
   72     72   
    ],
   73         -
);
          73  +
)
          74  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
          75  +
    "GET",
          76  +
    "/?metrics&x-id=ListBucketMetricsConfigurations",
          77  +
    None,
          78  +
));
   74     79   
impl ListBucketMetricsConfigurationsInput {
   75     80   
    /// The schema for this shape.
   76     81   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTBUCKETMETRICSCONFIGURATIONSINPUT_SCHEMA;
   77     82   
}
   78     83   
impl ::aws_smithy_schema::serde::SerializableStruct for ListBucketMetricsConfigurationsInput {
   79     84   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   80     85   
    fn serialize_members(
   81     86   
        &self,
   82     87   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   83     88   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   84     89   
        if let Some(ref val) = self.bucket {
   85     90   
            ser.write_string(&LISTBUCKETMETRICSCONFIGURATIONSINPUT_MEMBER_BUCKET, val)?;
   86     91   
        }
   87     92   
        if let Some(ref val) = self.continuation_token {
   88     93   
            ser.write_string(&LISTBUCKETMETRICSCONFIGURATIONSINPUT_MEMBER_CONTINUATION_TOKEN, val)?;
   89     94   
        }
   90     95   
        if let Some(ref val) = self.expected_bucket_owner {
   91     96   
            ser.write_string(&LISTBUCKETMETRICSCONFIGURATIONSINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
   92     97   
        }
   93     98   
        Ok(())
   94     99   
    }
   95    100   
}
   96    101   
impl ListBucketMetricsConfigurationsInput {
   97    102   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   98         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   99         -
        deserializer: &mut D,
         103  +
    pub fn deserialize(
         104  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  100    105   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  101    106   
        #[allow(unused_variables, unused_mut)]
  102    107   
        let mut builder = Self::builder();
  103    108   
        #[allow(
  104    109   
            unused_variables,
  105    110   
            unreachable_code,
  106    111   
            clippy::single_match,
  107    112   
            clippy::match_single_binding,
  108    113   
            clippy::diverging_sub_expression
  109    114   
        )]
  110         -
        deserializer.read_struct(&LISTBUCKETMETRICSCONFIGURATIONSINPUT_SCHEMA, (), |_, member, deser| {
         115  +
        deserializer.read_struct(&LISTBUCKETMETRICSCONFIGURATIONSINPUT_SCHEMA, &mut |member, deser| {
  111    116   
            match member.member_index() {
  112    117   
                Some(0) => {
  113    118   
                    builder.bucket = Some(deser.read_string(member)?);
  114    119   
                }
  115    120   
                Some(1) => {
  116    121   
                    builder.continuation_token = Some(deser.read_string(member)?);
  117    122   
                }
  118    123   
                Some(2) => {
  119    124   
                    builder.expected_bucket_owner = Some(deser.read_string(member)?);
  120    125   
                }
  121    126   
                _ => {}
  122    127   
            }
  123    128   
            Ok(())
  124    129   
        })?;
         130  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         131  +
        builder
         132  +
            .build()
         133  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         134  +
    }
         135  +
}
         136  +
impl ListBucketMetricsConfigurationsInput {
         137  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         138  +
    /// Header-bound members are read directly from headers, avoiding runtime
         139  +
    /// member iteration overhead. Body members are read via the deserializer.
         140  +
    pub fn deserialize_with_response(
         141  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         142  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         143  +
        _status: u16,
         144  +
        _body: &[u8],
         145  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         146  +
        #[allow(unused_variables, unused_mut)]
         147  +
        let mut builder = Self::builder();
         148  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         149  +
            builder.expected_bucket_owner = Some(val.to_string());
         150  +
        }
         151  +
        #[allow(
         152  +
            unused_variables,
         153  +
            unreachable_code,
         154  +
            clippy::single_match,
         155  +
            clippy::match_single_binding,
         156  +
            clippy::diverging_sub_expression
         157  +
        )]
         158  +
        deserializer.read_struct(&LISTBUCKETMETRICSCONFIGURATIONSINPUT_SCHEMA, &mut |member, deser| {
         159  +
            match member.member_index() {
         160  +
                Some(0) => {
         161  +
                    builder.bucket = Some(deser.read_string(member)?);
         162  +
                }
         163  +
                Some(1) => {
         164  +
                    builder.continuation_token = Some(deser.read_string(member)?);
         165  +
                }
         166  +
                Some(2) => { /* read from headers above */ }
         167  +
                _ => {}
         168  +
            }
         169  +
            Ok(())
         170  +
        })?;
  125    171   
        builder
  126    172   
            .build()
  127    173   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  128    174   
    }
  129    175   
}
  130    176   
impl ListBucketMetricsConfigurationsInput {
  131    177   
    /// Creates a new builder-style object to manufacture [`ListBucketMetricsConfigurationsInput`](crate::operation::list_bucket_metrics_configurations::ListBucketMetricsConfigurationsInput).
  132    178   
    pub fn builder() -> crate::operation::list_bucket_metrics_configurations::builders::ListBucketMetricsConfigurationsInputBuilder {
  133    179   
        crate::operation::list_bucket_metrics_configurations::builders::ListBucketMetricsConfigurationsInputBuilder::default()
  134    180   
    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_bucket_metrics_configurations/_list_bucket_metrics_configurations_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_buckets.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 `ListBuckets`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ListBuckets;
    6      6   
impl ListBuckets {
    7      7   
    /// Creates a new `ListBuckets`
    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::list_buckets::ListBucketsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::list_buckets::ListBucketsOutput::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::list_buckets::ListBucketsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::list_buckets::ListBucketsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::list_buckets::ListBucketsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -121,125 +183,188 @@
  141    145   
                    .build(),
  142    146   
            );
  143    147   
  144    148   
        ::std::borrow::Cow::Owned(rcb)
  145    149   
    }
  146    150   
}
  147    151   
  148    152   
#[derive(Debug)]
  149    153   
struct ListBucketsResponseDeserializer;
  150    154   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListBucketsResponseDeserializer {
  151         -
    fn deserialize_nonstreaming(
         155  +
    fn deserialize_nonstreaming_with_config(
  152    156   
        &self,
  153    157   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         158  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  154    159   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  155    160   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  156    161   
        let headers = response.headers();
  157    162   
        let body = response.body().bytes().expect("body loaded");
  158    163   
        #[allow(unused_mut)]
  159    164   
        let mut force_error = false;
  160    165   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  161    166   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  162    167   
            force_error = true;
  163    168   
        }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_buckets/_list_buckets_input.rs

@@ -27,27 +195,207 @@
   47     47   
    "com.amazonaws.s3.synthetic",
   48     48   
    "ListBucketsInput",
   49     49   
);
   50     50   
static LISTBUCKETSINPUT_MEMBER_MAX_BUCKETS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.s3.synthetic#ListBucketsInput$MaxBuckets",
   53     53   
        "com.amazonaws.s3.synthetic",
   54     54   
        "ListBucketsInput",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::Integer,
   57         -
    "max_buckets",
          57  +
    "MaxBuckets",
   58     58   
    0,
   59     59   
)
   60     60   
.with_http_query("max-buckets");
   61     61   
static LISTBUCKETSINPUT_MEMBER_CONTINUATION_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.s3.synthetic#ListBucketsInput$ContinuationToken",
   64     64   
        "com.amazonaws.s3.synthetic",
   65     65   
        "ListBucketsInput",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::String,
   68         -
    "continuation_token",
          68  +
    "ContinuationToken",
   69     69   
    1,
   70     70   
)
   71     71   
.with_http_query("continuation-token");
   72     72   
static LISTBUCKETSINPUT_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.s3.synthetic#ListBucketsInput$Prefix",
   75     75   
        "com.amazonaws.s3.synthetic",
   76     76   
        "ListBucketsInput",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "prefix",
          79  +
    "Prefix",
   80     80   
    2,
   81     81   
)
   82     82   
.with_http_query("prefix");
   83     83   
static LISTBUCKETSINPUT_MEMBER_BUCKET_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.s3.synthetic#ListBucketsInput$BucketRegion",
   86     86   
        "com.amazonaws.s3.synthetic",
   87     87   
        "ListBucketsInput",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "bucket_region",
          90  +
    "BucketRegion",
   91     91   
    3,
   92     92   
)
   93     93   
.with_http_query("bucket-region");
   94     94   
static LISTBUCKETSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   95     95   
    LISTBUCKETSINPUT_SCHEMA_ID,
   96     96   
    ::aws_smithy_schema::ShapeType::Structure,
   97     97   
    &[
   98     98   
        &LISTBUCKETSINPUT_MEMBER_MAX_BUCKETS,
   99     99   
        &LISTBUCKETSINPUT_MEMBER_CONTINUATION_TOKEN,
  100    100   
        &LISTBUCKETSINPUT_MEMBER_PREFIX,
  101    101   
        &LISTBUCKETSINPUT_MEMBER_BUCKET_REGION,
  102    102   
    ],
  103         -
);
         103  +
)
         104  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/?x-id=ListBuckets", None));
  104    105   
impl ListBucketsInput {
  105    106   
    /// The schema for this shape.
  106    107   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTBUCKETSINPUT_SCHEMA;
  107    108   
}
  108    109   
impl ::aws_smithy_schema::serde::SerializableStruct for ListBucketsInput {
  109    110   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  110    111   
    fn serialize_members(
  111    112   
        &self,
  112    113   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  113    114   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  114    115   
        if let Some(ref val) = self.max_buckets {
  115    116   
            ser.write_integer(&LISTBUCKETSINPUT_MEMBER_MAX_BUCKETS, *val)?;
  116    117   
        }
  117    118   
        if let Some(ref val) = self.continuation_token {
  118    119   
            ser.write_string(&LISTBUCKETSINPUT_MEMBER_CONTINUATION_TOKEN, val)?;
  119    120   
        }
  120    121   
        if let Some(ref val) = self.prefix {
  121    122   
            ser.write_string(&LISTBUCKETSINPUT_MEMBER_PREFIX, val)?;
  122    123   
        }
  123    124   
        if let Some(ref val) = self.bucket_region {
  124    125   
            ser.write_string(&LISTBUCKETSINPUT_MEMBER_BUCKET_REGION, val)?;
  125    126   
        }
  126    127   
        Ok(())
  127    128   
    }
  128    129   
}
  129    130   
impl ListBucketsInput {
  130    131   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  131         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  132         -
        deserializer: &mut D,
         132  +
    pub fn deserialize(
         133  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  133    134   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  134    135   
        #[allow(unused_variables, unused_mut)]
  135    136   
        let mut builder = Self::builder();
  136    137   
        #[allow(
  137    138   
            unused_variables,
  138    139   
            unreachable_code,
  139    140   
            clippy::single_match,
  140    141   
            clippy::match_single_binding,
  141    142   
            clippy::diverging_sub_expression
  142    143   
        )]
  143         -
        deserializer.read_struct(&LISTBUCKETSINPUT_SCHEMA, (), |_, member, deser| {
         144  +
        deserializer.read_struct(&LISTBUCKETSINPUT_SCHEMA, &mut |member, deser| {
  144    145   
            match member.member_index() {
  145    146   
                Some(0) => {
  146    147   
                    builder.max_buckets = Some(deser.read_integer(member)?);
  147    148   
                }
  148    149   
                Some(1) => {
  149    150   
                    builder.continuation_token = Some(deser.read_string(member)?);
  150    151   
                }
  151    152   
                Some(2) => {
  152    153   
                    builder.prefix = Some(deser.read_string(member)?);
  153    154   
                }
  154    155   
                Some(3) => {
  155    156   
                    builder.bucket_region = Some(deser.read_string(member)?);
  156    157   
                }
  157    158   
                _ => {}
  158    159   
            }
  159    160   
            Ok(())
  160    161   
        })?;
  161    162   
        builder
  162    163   
            .build()
  163    164   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  164    165   
    }
  165    166   
}
         167  +
impl ListBucketsInput {
         168  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         169  +
    pub fn deserialize_with_response(
         170  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         171  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         172  +
        _status: u16,
         173  +
        _body: &[u8],
         174  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         175  +
        Self::deserialize(deserializer)
         176  +
    }
         177  +
}
  166    178   
impl ListBucketsInput {
  167    179   
    /// Creates a new builder-style object to manufacture [`ListBucketsInput`](crate::operation::list_buckets::ListBucketsInput).
  168    180   
    pub fn builder() -> crate::operation::list_buckets::builders::ListBucketsInputBuilder {
  169    181   
        crate::operation::list_buckets::builders::ListBucketsInputBuilder::default()
  170    182   
    }
  171    183   
}
  172    184   
  173    185   
/// A builder for [`ListBucketsInput`](crate::operation::list_buckets::ListBucketsInput).
  174    186   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  175    187   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_buckets/_list_buckets_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_directory_buckets/_list_directory_buckets_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_directory_buckets/_list_directory_buckets_output.rs

@@ -7,7 +142,194 @@
   27     27   
    "com.amazonaws.s3.synthetic",
   28     28   
    "ListDirectoryBucketsOutput",
   29     29   
);
   30     30   
static LISTDIRECTORYBUCKETSOUTPUT_MEMBER_BUCKETS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static(
   32     32   
        "com.amazonaws.s3.synthetic#ListDirectoryBucketsOutput$Buckets",
   33     33   
        "com.amazonaws.s3.synthetic",
   34     34   
        "ListDirectoryBucketsOutput",
   35     35   
    ),
   36     36   
    ::aws_smithy_schema::ShapeType::List,
   37         -
    "buckets",
          37  +
    "Buckets",
   38     38   
    0,
   39     39   
);
   40     40   
static LISTDIRECTORYBUCKETSOUTPUT_MEMBER_CONTINUATION_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.s3.synthetic#ListDirectoryBucketsOutput$ContinuationToken",
   43     43   
        "com.amazonaws.s3.synthetic",
   44     44   
        "ListDirectoryBucketsOutput",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::String,
   47         -
    "continuation_token",
          47  +
    "ContinuationToken",
   48     48   
    1,
   49     49   
);
          50  +
static LISTDIRECTORYBUCKETSOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          51  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          52  +
    ::aws_smithy_schema::ShapeType::String,
          53  +
    "request_id",
          54  +
    2,
          55  +
)
          56  +
.with_http_header("x-amzn-requestid");
   50     57   
static LISTDIRECTORYBUCKETSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   51     58   
    LISTDIRECTORYBUCKETSOUTPUT_SCHEMA_ID,
   52     59   
    ::aws_smithy_schema::ShapeType::Structure,
   53     60   
    &[
   54     61   
        &LISTDIRECTORYBUCKETSOUTPUT_MEMBER_BUCKETS,
   55     62   
        &LISTDIRECTORYBUCKETSOUTPUT_MEMBER_CONTINUATION_TOKEN,
          63  +
        &LISTDIRECTORYBUCKETSOUTPUT_MEMBER__REQUEST_ID,
   56     64   
    ],
   57     65   
)
   58     66   
.with_xml_name("ListAllMyDirectoryBucketsResult");
   59     67   
impl ListDirectoryBucketsOutput {
   60     68   
    /// The schema for this shape.
   61     69   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTDIRECTORYBUCKETSOUTPUT_SCHEMA;
   62     70   
}
   63     71   
impl ::aws_smithy_schema::serde::SerializableStruct for ListDirectoryBucketsOutput {
   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.buckets {
   70     78   
            ser.write_list(
   71     79   
                &LISTDIRECTORYBUCKETSOUTPUT_MEMBER_BUCKETS,
   72     80   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   73     81   
                    for item in val {
   74     82   
                        ser.write_struct(crate::types::Bucket::SCHEMA, item)?;
   75     83   
                    }
   76     84   
                    Ok(())
   77     85   
                },
   78     86   
            )?;
   79     87   
        }
   80     88   
        if let Some(ref val) = self.continuation_token {
   81     89   
            ser.write_string(&LISTDIRECTORYBUCKETSOUTPUT_MEMBER_CONTINUATION_TOKEN, val)?;
   82     90   
        }
   83     91   
        Ok(())
   84     92   
    }
   85     93   
}
   86     94   
impl ListDirectoryBucketsOutput {
   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(&LISTDIRECTORYBUCKETSOUTPUT_SCHEMA, &mut |member, deser| {
         109  +
            match member.member_index() {
         110  +
                Some(0) => {
         111  +
                    builder.buckets = Some({
         112  +
                        let mut container = Vec::new();
         113  +
                        deser.read_list(member, &mut |deser| {
         114  +
                            container.push(crate::types::Bucket::deserialize(deser)?);
         115  +
                            Ok(())
         116  +
                        })?;
         117  +
                        container
         118  +
                    });
         119  +
                }
         120  +
                Some(1) => {
         121  +
                    builder.continuation_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 ListDirectoryBucketsOutput {
         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(&LISTDIRECTORYBUCKETSOUTPUT_SCHEMA, (), |_, member, deser| {
         155  +
        deserializer.read_struct(&LISTDIRECTORYBUCKETSOUTPUT_SCHEMA, &mut |member, deser| {
  101    156   
            match member.member_index() {
  102    157   
                Some(0) => {
  103    158   
                    builder.buckets = 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::Bucket::deserialize(deser)?);
  111         -
                            Ok(list)
  112         -
                        })?
         159  +
                        let mut container = Vec::new();
         160  +
                        deser.read_list(member, &mut |deser| {
         161  +
                            container.push(crate::types::Bucket::deserialize(deser)?);
         162  +
                            Ok(())
         163  +
                        })?;
         164  +
                        container
  113    165   
                    });
  114    166   
                }
  115    167   
                Some(1) => {
  116    168   
                    builder.continuation_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/s3/src/operation/list_multipart_uploads.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 `ListMultipartUploads`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ListMultipartUploads;
    6      6   
impl ListMultipartUploads {
    7      7   
    /// Creates a new `ListMultipartUploads`
    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::list_multipart_uploads::ListMultipartUploadsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::list_multipart_uploads::ListMultipartUploadsOutput::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::list_multipart_uploads::ListMultipartUploadsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::list_multipart_uploads::ListMultipartUploadsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::list_multipart_uploads::ListMultipartUploadsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -116,120 +178,183 @@
  136    140   
                                            ::std::borrow::Cow::Owned(transient_errors)
  137    141   
                                            }).build());
  138    142   
  139    143   
        ::std::borrow::Cow::Owned(rcb)
  140    144   
    }
  141    145   
}
  142    146   
  143    147   
#[derive(Debug)]
  144    148   
struct ListMultipartUploadsResponseDeserializer;
  145    149   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListMultipartUploadsResponseDeserializer {
  146         -
    fn deserialize_nonstreaming(
         150  +
    fn deserialize_nonstreaming_with_config(
  147    151   
        &self,
  148    152   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         153  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  149    154   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  150    155   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  151    156   
        let headers = response.headers();
  152    157   
        let body = response.body().bytes().expect("body loaded");
  153    158   
        #[allow(unused_mut)]
  154    159   
        let mut force_error = false;
  155    160   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  156    161   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  157    162   
            force_error = true;
  158    163   
        }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_multipart_uploads/_list_multipart_uploads_input.rs

@@ -99,99 +352,413 @@
  119    119   
    "com.amazonaws.s3.synthetic",
  120    120   
    "ListMultipartUploadsInput",
  121    121   
);
  122    122   
static LISTMULTIPARTUPLOADSINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  123    123   
    ::aws_smithy_schema::ShapeId::from_static(
  124    124   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsInput$Bucket",
  125    125   
        "com.amazonaws.s3.synthetic",
  126    126   
        "ListMultipartUploadsInput",
  127    127   
    ),
  128    128   
    ::aws_smithy_schema::ShapeType::String,
  129         -
    "bucket",
         129  +
    "Bucket",
  130    130   
    0,
  131    131   
)
  132    132   
.with_http_label();
  133    133   
static LISTMULTIPARTUPLOADSINPUT_MEMBER_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  134    134   
    ::aws_smithy_schema::ShapeId::from_static(
  135    135   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsInput$Delimiter",
  136    136   
        "com.amazonaws.s3.synthetic",
  137    137   
        "ListMultipartUploadsInput",
  138    138   
    ),
  139    139   
    ::aws_smithy_schema::ShapeType::String,
  140         -
    "delimiter",
         140  +
    "Delimiter",
  141    141   
    1,
  142    142   
)
  143    143   
.with_http_query("delimiter");
  144    144   
static LISTMULTIPARTUPLOADSINPUT_MEMBER_ENCODING_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsInput$EncodingType",
  147    147   
        "com.amazonaws.s3.synthetic",
  148    148   
        "ListMultipartUploadsInput",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::String,
  151         -
    "encoding_type",
         151  +
    "EncodingType",
  152    152   
    2,
  153    153   
)
  154    154   
.with_http_query("encoding-type");
  155    155   
static LISTMULTIPARTUPLOADSINPUT_MEMBER_KEY_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  156    156   
    ::aws_smithy_schema::ShapeId::from_static(
  157    157   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsInput$KeyMarker",
  158    158   
        "com.amazonaws.s3.synthetic",
  159    159   
        "ListMultipartUploadsInput",
  160    160   
    ),
  161    161   
    ::aws_smithy_schema::ShapeType::String,
  162         -
    "key_marker",
         162  +
    "KeyMarker",
  163    163   
    3,
  164    164   
)
  165    165   
.with_http_query("key-marker");
  166    166   
static LISTMULTIPARTUPLOADSINPUT_MEMBER_MAX_UPLOADS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  167    167   
    ::aws_smithy_schema::ShapeId::from_static(
  168    168   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsInput$MaxUploads",
  169    169   
        "com.amazonaws.s3.synthetic",
  170    170   
        "ListMultipartUploadsInput",
  171    171   
    ),
  172    172   
    ::aws_smithy_schema::ShapeType::Integer,
  173         -
    "max_uploads",
         173  +
    "MaxUploads",
  174    174   
    4,
  175    175   
)
  176    176   
.with_http_query("max-uploads");
  177    177   
static LISTMULTIPARTUPLOADSINPUT_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  178    178   
    ::aws_smithy_schema::ShapeId::from_static(
  179    179   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsInput$Prefix",
  180    180   
        "com.amazonaws.s3.synthetic",
  181    181   
        "ListMultipartUploadsInput",
  182    182   
    ),
  183    183   
    ::aws_smithy_schema::ShapeType::String,
  184         -
    "prefix",
         184  +
    "Prefix",
  185    185   
    5,
  186    186   
)
  187    187   
.with_http_query("prefix");
  188    188   
static LISTMULTIPARTUPLOADSINPUT_MEMBER_UPLOAD_ID_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  189    189   
    ::aws_smithy_schema::ShapeId::from_static(
  190    190   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsInput$UploadIdMarker",
  191    191   
        "com.amazonaws.s3.synthetic",
  192    192   
        "ListMultipartUploadsInput",
  193    193   
    ),
  194    194   
    ::aws_smithy_schema::ShapeType::String,
  195         -
    "upload_id_marker",
         195  +
    "UploadIdMarker",
  196    196   
    6,
  197    197   
)
  198    198   
.with_http_query("upload-id-marker");
  199    199   
static LISTMULTIPARTUPLOADSINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  200    200   
    ::aws_smithy_schema::ShapeId::from_static(
  201    201   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsInput$ExpectedBucketOwner",
  202    202   
        "com.amazonaws.s3.synthetic",
  203    203   
        "ListMultipartUploadsInput",
  204    204   
    ),
  205    205   
    ::aws_smithy_schema::ShapeType::String,
  206         -
    "expected_bucket_owner",
         206  +
    "ExpectedBucketOwner",
  207    207   
    7,
  208    208   
)
  209    209   
.with_http_header("x-amz-expected-bucket-owner");
  210    210   
static LISTMULTIPARTUPLOADSINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  211    211   
    ::aws_smithy_schema::ShapeId::from_static(
  212    212   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsInput$RequestPayer",
  213    213   
        "com.amazonaws.s3.synthetic",
  214    214   
        "ListMultipartUploadsInput",
  215    215   
    ),
  216    216   
    ::aws_smithy_schema::ShapeType::String,
  217         -
    "request_payer",
         217  +
    "RequestPayer",
  218    218   
    8,
  219    219   
)
  220    220   
.with_http_header("x-amz-request-payer");
  221    221   
static LISTMULTIPARTUPLOADSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  222    222   
    LISTMULTIPARTUPLOADSINPUT_SCHEMA_ID,
  223    223   
    ::aws_smithy_schema::ShapeType::Structure,
  224    224   
    &[
  225    225   
        &LISTMULTIPARTUPLOADSINPUT_MEMBER_BUCKET,
  226    226   
        &LISTMULTIPARTUPLOADSINPUT_MEMBER_DELIMITER,
  227    227   
        &LISTMULTIPARTUPLOADSINPUT_MEMBER_ENCODING_TYPE,
  228    228   
        &LISTMULTIPARTUPLOADSINPUT_MEMBER_KEY_MARKER,
  229    229   
        &LISTMULTIPARTUPLOADSINPUT_MEMBER_MAX_UPLOADS,
  230    230   
        &LISTMULTIPARTUPLOADSINPUT_MEMBER_PREFIX,
  231    231   
        &LISTMULTIPARTUPLOADSINPUT_MEMBER_UPLOAD_ID_MARKER,
  232    232   
        &LISTMULTIPARTUPLOADSINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
  233    233   
        &LISTMULTIPARTUPLOADSINPUT_MEMBER_REQUEST_PAYER,
  234    234   
    ],
  235         -
);
         235  +
)
         236  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/?uploads", None));
  236    237   
impl ListMultipartUploadsInput {
  237    238   
    /// The schema for this shape.
  238    239   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTMULTIPARTUPLOADSINPUT_SCHEMA;
  239    240   
}
  240    241   
impl ::aws_smithy_schema::serde::SerializableStruct for ListMultipartUploadsInput {
  241    242   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  242    243   
    fn serialize_members(
  243    244   
        &self,
  244    245   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  245    246   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  246    247   
        if let Some(ref val) = self.bucket {
  247    248   
            ser.write_string(&LISTMULTIPARTUPLOADSINPUT_MEMBER_BUCKET, val)?;
  248    249   
        }
  249    250   
        if let Some(ref val) = self.delimiter {
  250    251   
            ser.write_string(&LISTMULTIPARTUPLOADSINPUT_MEMBER_DELIMITER, val)?;
  251    252   
        }
  252    253   
        if let Some(ref val) = self.encoding_type {
  253    254   
            ser.write_string(&LISTMULTIPARTUPLOADSINPUT_MEMBER_ENCODING_TYPE, val.as_str())?;
  254    255   
        }
  255    256   
        if let Some(ref val) = self.key_marker {
  256    257   
            ser.write_string(&LISTMULTIPARTUPLOADSINPUT_MEMBER_KEY_MARKER, val)?;
  257    258   
        }
  258    259   
        if let Some(ref val) = self.max_uploads {
  259    260   
            ser.write_integer(&LISTMULTIPARTUPLOADSINPUT_MEMBER_MAX_UPLOADS, *val)?;
  260    261   
        }
  261    262   
        if let Some(ref val) = self.prefix {
  262    263   
            ser.write_string(&LISTMULTIPARTUPLOADSINPUT_MEMBER_PREFIX, val)?;
  263    264   
        }
  264    265   
        if let Some(ref val) = self.upload_id_marker {
  265    266   
            ser.write_string(&LISTMULTIPARTUPLOADSINPUT_MEMBER_UPLOAD_ID_MARKER, val)?;
  266    267   
        }
  267    268   
        if let Some(ref val) = self.expected_bucket_owner {
  268    269   
            ser.write_string(&LISTMULTIPARTUPLOADSINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
  269    270   
        }
  270    271   
        if let Some(ref val) = self.request_payer {
  271    272   
            ser.write_string(&LISTMULTIPARTUPLOADSINPUT_MEMBER_REQUEST_PAYER, val.as_str())?;
  272    273   
        }
  273    274   
        Ok(())
  274    275   
    }
  275    276   
}
  276    277   
impl ListMultipartUploadsInput {
  277    278   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  278         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  279         -
        deserializer: &mut D,
         279  +
    pub fn deserialize(
         280  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  280    281   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  281    282   
        #[allow(unused_variables, unused_mut)]
  282    283   
        let mut builder = Self::builder();
  283    284   
        #[allow(
  284    285   
            unused_variables,
  285    286   
            unreachable_code,
  286    287   
            clippy::single_match,
  287    288   
            clippy::match_single_binding,
  288    289   
            clippy::diverging_sub_expression
  289    290   
        )]
  290         -
        deserializer.read_struct(&LISTMULTIPARTUPLOADSINPUT_SCHEMA, (), |_, member, deser| {
         291  +
        deserializer.read_struct(&LISTMULTIPARTUPLOADSINPUT_SCHEMA, &mut |member, deser| {
  291    292   
            match member.member_index() {
  292    293   
                Some(0) => {
  293    294   
                    builder.bucket = Some(deser.read_string(member)?);
  294    295   
                }
  295    296   
                Some(1) => {
  296    297   
                    builder.delimiter = Some(deser.read_string(member)?);
  297    298   
                }
  298    299   
                Some(2) => {
  299    300   
                    builder.encoding_type = Some(crate::types::EncodingType::from(deser.read_string(member)?.as_str()));
  300    301   
                }
  301    302   
                Some(3) => {
  302    303   
                    builder.key_marker = Some(deser.read_string(member)?);
  303    304   
                }
  304    305   
                Some(4) => {
  305    306   
                    builder.max_uploads = Some(deser.read_integer(member)?);
  306    307   
                }
  307    308   
                Some(5) => {
  308    309   
                    builder.prefix = Some(deser.read_string(member)?);
  309    310   
                }
  310    311   
                Some(6) => {
  311    312   
                    builder.upload_id_marker = Some(deser.read_string(member)?);
  312    313   
                }
  313    314   
                Some(7) => {
  314    315   
                    builder.expected_bucket_owner = Some(deser.read_string(member)?);
  315    316   
                }
  316    317   
                Some(8) => {
  317    318   
                    builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
  318    319   
                }
  319    320   
                _ => {}
  320    321   
            }
  321    322   
            Ok(())
  322    323   
        })?;
         324  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         325  +
        builder
         326  +
            .build()
         327  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         328  +
    }
         329  +
}
         330  +
impl ListMultipartUploadsInput {
         331  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         332  +
    /// Header-bound members are read directly from headers, avoiding runtime
         333  +
    /// member iteration overhead. Body members are read via the deserializer.
         334  +
    pub fn deserialize_with_response(
         335  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         336  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         337  +
        _status: u16,
         338  +
        _body: &[u8],
         339  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         340  +
        #[allow(unused_variables, unused_mut)]
         341  +
        let mut builder = Self::builder();
         342  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         343  +
            builder.expected_bucket_owner = Some(val.to_string());
         344  +
        }
         345  +
        if let Some(val) = headers.get("x-amz-request-payer") {
         346  +
            builder.request_payer = Some(crate::types::RequestPayer::from(val));
         347  +
        }
         348  +
        #[allow(
         349  +
            unused_variables,
         350  +
            unreachable_code,
         351  +
            clippy::single_match,
         352  +
            clippy::match_single_binding,
         353  +
            clippy::diverging_sub_expression
         354  +
        )]
         355  +
        deserializer.read_struct(&LISTMULTIPARTUPLOADSINPUT_SCHEMA, &mut |member, deser| {
         356  +
            match member.member_index() {
         357  +
                Some(0) => {
         358  +
                    builder.bucket = Some(deser.read_string(member)?);
         359  +
                }
         360  +
                Some(1) => {
         361  +
                    builder.delimiter = Some(deser.read_string(member)?);
         362  +
                }
         363  +
                Some(2) => {
         364  +
                    builder.encoding_type = Some(crate::types::EncodingType::from(deser.read_string(member)?.as_str()));
         365  +
                }
         366  +
                Some(3) => {
         367  +
                    builder.key_marker = Some(deser.read_string(member)?);
         368  +
                }
         369  +
                Some(4) => {
         370  +
                    builder.max_uploads = Some(deser.read_integer(member)?);
         371  +
                }
         372  +
                Some(5) => {
         373  +
                    builder.prefix = Some(deser.read_string(member)?);
         374  +
                }
         375  +
                Some(6) => {
         376  +
                    builder.upload_id_marker = Some(deser.read_string(member)?);
         377  +
                }
         378  +
                Some(7) => { /* read from headers above */ }
         379  +
                Some(8) => { /* read from headers above */ }
         380  +
                _ => {}
         381  +
            }
         382  +
            Ok(())
         383  +
        })?;
  323    384   
        builder
  324    385   
            .build()
  325    386   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  326    387   
    }
  327    388   
}
  328    389   
impl ListMultipartUploadsInput {
  329    390   
    /// Creates a new builder-style object to manufacture [`ListMultipartUploadsInput`](crate::operation::list_multipart_uploads::ListMultipartUploadsInput).
  330    391   
    pub fn builder() -> crate::operation::list_multipart_uploads::builders::ListMultipartUploadsInputBuilder {
  331    392   
        crate::operation::list_multipart_uploads::builders::ListMultipartUploadsInputBuilder::default()
  332    393   
    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_multipart_uploads/_list_multipart_uploads_output.rs

@@ -103,103 +306,314 @@
  123    123   
    "com.amazonaws.s3.synthetic",
  124    124   
    "ListMultipartUploadsOutput",
  125    125   
);
  126    126   
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  127    127   
    ::aws_smithy_schema::ShapeId::from_static(
  128    128   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsOutput$Bucket",
  129    129   
        "com.amazonaws.s3.synthetic",
  130    130   
        "ListMultipartUploadsOutput",
  131    131   
    ),
  132    132   
    ::aws_smithy_schema::ShapeType::String,
  133         -
    "bucket",
         133  +
    "Bucket",
  134    134   
    0,
  135    135   
);
  136    136   
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER_KEY_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  137    137   
    ::aws_smithy_schema::ShapeId::from_static(
  138    138   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsOutput$KeyMarker",
  139    139   
        "com.amazonaws.s3.synthetic",
  140    140   
        "ListMultipartUploadsOutput",
  141    141   
    ),
  142    142   
    ::aws_smithy_schema::ShapeType::String,
  143         -
    "key_marker",
         143  +
    "KeyMarker",
  144    144   
    1,
  145    145   
);
  146    146   
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER_UPLOAD_ID_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  147    147   
    ::aws_smithy_schema::ShapeId::from_static(
  148    148   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsOutput$UploadIdMarker",
  149    149   
        "com.amazonaws.s3.synthetic",
  150    150   
        "ListMultipartUploadsOutput",
  151    151   
    ),
  152    152   
    ::aws_smithy_schema::ShapeType::String,
  153         -
    "upload_id_marker",
         153  +
    "UploadIdMarker",
  154    154   
    2,
  155    155   
);
  156    156   
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER_NEXT_KEY_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  157    157   
    ::aws_smithy_schema::ShapeId::from_static(
  158    158   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsOutput$NextKeyMarker",
  159    159   
        "com.amazonaws.s3.synthetic",
  160    160   
        "ListMultipartUploadsOutput",
  161    161   
    ),
  162    162   
    ::aws_smithy_schema::ShapeType::String,
  163         -
    "next_key_marker",
         163  +
    "NextKeyMarker",
  164    164   
    3,
  165    165   
);
  166    166   
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  167    167   
    ::aws_smithy_schema::ShapeId::from_static(
  168    168   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsOutput$Prefix",
  169    169   
        "com.amazonaws.s3.synthetic",
  170    170   
        "ListMultipartUploadsOutput",
  171    171   
    ),
  172    172   
    ::aws_smithy_schema::ShapeType::String,
  173         -
    "prefix",
         173  +
    "Prefix",
  174    174   
    4,
  175    175   
);
  176    176   
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  177    177   
    ::aws_smithy_schema::ShapeId::from_static(
  178    178   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsOutput$Delimiter",
  179    179   
        "com.amazonaws.s3.synthetic",
  180    180   
        "ListMultipartUploadsOutput",
  181    181   
    ),
  182    182   
    ::aws_smithy_schema::ShapeType::String,
  183         -
    "delimiter",
         183  +
    "Delimiter",
  184    184   
    5,
  185    185   
);
  186    186   
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER_NEXT_UPLOAD_ID_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  187    187   
    ::aws_smithy_schema::ShapeId::from_static(
  188    188   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsOutput$NextUploadIdMarker",
  189    189   
        "com.amazonaws.s3.synthetic",
  190    190   
        "ListMultipartUploadsOutput",
  191    191   
    ),
  192    192   
    ::aws_smithy_schema::ShapeType::String,
  193         -
    "next_upload_id_marker",
         193  +
    "NextUploadIdMarker",
  194    194   
    6,
  195    195   
);
  196    196   
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER_MAX_UPLOADS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  197    197   
    ::aws_smithy_schema::ShapeId::from_static(
  198    198   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsOutput$MaxUploads",
  199    199   
        "com.amazonaws.s3.synthetic",
  200    200   
        "ListMultipartUploadsOutput",
  201    201   
    ),
  202    202   
    ::aws_smithy_schema::ShapeType::Integer,
  203         -
    "max_uploads",
         203  +
    "MaxUploads",
  204    204   
    7,
  205    205   
);
  206    206   
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER_IS_TRUNCATED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  207    207   
    ::aws_smithy_schema::ShapeId::from_static(
  208    208   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsOutput$IsTruncated",
  209    209   
        "com.amazonaws.s3.synthetic",
  210    210   
        "ListMultipartUploadsOutput",
  211    211   
    ),
  212    212   
    ::aws_smithy_schema::ShapeType::Boolean,
  213         -
    "is_truncated",
         213  +
    "IsTruncated",
  214    214   
    8,
  215    215   
);
  216    216   
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER_UPLOADS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  217    217   
    ::aws_smithy_schema::ShapeId::from_static(
  218    218   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsOutput$Uploads",
  219    219   
        "com.amazonaws.s3.synthetic",
  220    220   
        "ListMultipartUploadsOutput",
  221    221   
    ),
  222    222   
    ::aws_smithy_schema::ShapeType::List,
  223         -
    "uploads",
         223  +
    "Uploads",
  224    224   
    9,
  225    225   
)
  226    226   
.with_xml_name("Upload")
  227    227   
.with_xml_flattened();
  228    228   
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER_COMMON_PREFIXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  229    229   
    ::aws_smithy_schema::ShapeId::from_static(
  230    230   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsOutput$CommonPrefixes",
  231    231   
        "com.amazonaws.s3.synthetic",
  232    232   
        "ListMultipartUploadsOutput",
  233    233   
    ),
  234    234   
    ::aws_smithy_schema::ShapeType::List,
  235         -
    "common_prefixes",
         235  +
    "CommonPrefixes",
  236    236   
    10,
  237    237   
)
  238    238   
.with_xml_flattened();
  239    239   
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER_ENCODING_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  240    240   
    ::aws_smithy_schema::ShapeId::from_static(
  241    241   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsOutput$EncodingType",
  242    242   
        "com.amazonaws.s3.synthetic",
  243    243   
        "ListMultipartUploadsOutput",
  244    244   
    ),
  245    245   
    ::aws_smithy_schema::ShapeType::String,
  246         -
    "encoding_type",
         246  +
    "EncodingType",
  247    247   
    11,
  248    248   
);
  249    249   
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  250    250   
    ::aws_smithy_schema::ShapeId::from_static(
  251    251   
        "com.amazonaws.s3.synthetic#ListMultipartUploadsOutput$RequestCharged",
  252    252   
        "com.amazonaws.s3.synthetic",
  253    253   
        "ListMultipartUploadsOutput",
  254    254   
    ),
  255    255   
    ::aws_smithy_schema::ShapeType::String,
  256         -
    "request_charged",
         256  +
    "RequestCharged",
  257    257   
    12,
  258    258   
)
  259    259   
.with_http_header("x-amz-request-charged");
         260  +
static LISTMULTIPARTUPLOADSOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         261  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         262  +
    ::aws_smithy_schema::ShapeType::String,
         263  +
    "request_id",
         264  +
    13,
         265  +
)
         266  +
.with_http_header("x-amzn-requestid");
  260    267   
static LISTMULTIPARTUPLOADSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  261    268   
    LISTMULTIPARTUPLOADSOUTPUT_SCHEMA_ID,
  262    269   
    ::aws_smithy_schema::ShapeType::Structure,
  263    270   
    &[
  264    271   
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER_BUCKET,
  265    272   
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER_KEY_MARKER,
  266    273   
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER_UPLOAD_ID_MARKER,
  267    274   
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER_NEXT_KEY_MARKER,
  268    275   
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER_PREFIX,
  269    276   
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER_DELIMITER,
  270    277   
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER_NEXT_UPLOAD_ID_MARKER,
  271    278   
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER_MAX_UPLOADS,
  272    279   
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER_IS_TRUNCATED,
  273    280   
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER_UPLOADS,
  274    281   
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER_COMMON_PREFIXES,
  275    282   
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER_ENCODING_TYPE,
  276    283   
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER_REQUEST_CHARGED,
         284  +
        &LISTMULTIPARTUPLOADSOUTPUT_MEMBER__REQUEST_ID,
  277    285   
    ],
  278    286   
)
  279    287   
.with_xml_name("ListMultipartUploadsResult");
  280    288   
impl ListMultipartUploadsOutput {
  281    289   
    /// The schema for this shape.
  282    290   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTMULTIPARTUPLOADSOUTPUT_SCHEMA;
  283    291   
}
  284    292   
impl ::aws_smithy_schema::serde::SerializableStruct for ListMultipartUploadsOutput {
  285    293   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  286    294   
    fn serialize_members(
@@ -320,328 +452,542 @@
  340    348   
            ser.write_string(&LISTMULTIPARTUPLOADSOUTPUT_MEMBER_ENCODING_TYPE, val.as_str())?;
  341    349   
        }
  342    350   
        if let Some(ref val) = self.request_charged {
  343    351   
            ser.write_string(&LISTMULTIPARTUPLOADSOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
  344    352   
        }
  345    353   
        Ok(())
  346    354   
    }
  347    355   
}
  348    356   
impl ListMultipartUploadsOutput {
  349    357   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  350         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  351         -
        deserializer: &mut D,
         358  +
    pub fn deserialize(
         359  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  352    360   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  353    361   
        #[allow(unused_variables, unused_mut)]
  354    362   
        let mut builder = Self::builder();
  355    363   
        #[allow(
  356    364   
            unused_variables,
  357    365   
            unreachable_code,
  358    366   
            clippy::single_match,
  359    367   
            clippy::match_single_binding,
  360    368   
            clippy::diverging_sub_expression
  361    369   
        )]
  362         -
        deserializer.read_struct(&LISTMULTIPARTUPLOADSOUTPUT_SCHEMA, (), |_, member, deser| {
         370  +
        deserializer.read_struct(&LISTMULTIPARTUPLOADSOUTPUT_SCHEMA, &mut |member, deser| {
  363    371   
            match member.member_index() {
  364    372   
                Some(0) => {
  365    373   
                    builder.bucket = Some(deser.read_string(member)?);
  366    374   
                }
  367    375   
                Some(1) => {
  368    376   
                    builder.key_marker = Some(deser.read_string(member)?);
  369    377   
                }
  370    378   
                Some(2) => {
  371    379   
                    builder.upload_id_marker = Some(deser.read_string(member)?);
  372    380   
                }
  373    381   
                Some(3) => {
  374    382   
                    builder.next_key_marker = Some(deser.read_string(member)?);
  375    383   
                }
  376    384   
                Some(4) => {
  377    385   
                    builder.prefix = Some(deser.read_string(member)?);
  378    386   
                }
  379    387   
                Some(5) => {
  380    388   
                    builder.delimiter = Some(deser.read_string(member)?);
  381    389   
                }
  382    390   
                Some(6) => {
  383    391   
                    builder.next_upload_id_marker = Some(deser.read_string(member)?);
  384    392   
                }
  385    393   
                Some(7) => {
  386    394   
                    builder.max_uploads = Some(deser.read_integer(member)?);
  387    395   
                }
  388    396   
                Some(8) => {
  389    397   
                    builder.is_truncated = Some(deser.read_boolean(member)?);
  390    398   
                }
  391    399   
                Some(9) => {
  392    400   
                    builder.uploads = Some({
  393         -
                        let container = if let Some(cap) = deser.container_size() {
  394         -
                            Vec::with_capacity(cap)
  395         -
                        } else {
  396         -
                            Vec::new()
  397         -
                        };
  398         -
                        deser.read_list(member, container, |mut list, deser| {
  399         -
                            list.push(crate::types::MultipartUpload::deserialize(deser)?);
  400         -
                            Ok(list)
  401         -
                        })?
         401  +
                        let mut container = Vec::new();
         402  +
                        deser.read_list(member, &mut |deser| {
         403  +
                            container.push(crate::types::MultipartUpload::deserialize(deser)?);
         404  +
                            Ok(())
         405  +
                        })?;
         406  +
                        container
  402    407   
                    });
  403    408   
                }
  404    409   
                Some(10) => {
  405    410   
                    builder.common_prefixes = Some({
  406         -
                        let container = if let Some(cap) = deser.container_size() {
  407         -
                            Vec::with_capacity(cap)
  408         -
                        } else {
  409         -
                            Vec::new()
  410         -
                        };
  411         -
                        deser.read_list(member, container, |mut list, deser| {
  412         -
                            list.push(crate::types::CommonPrefix::deserialize(deser)?);
  413         -
                            Ok(list)
  414         -
                        })?
         411  +
                        let mut container = Vec::new();
         412  +
                        deser.read_list(member, &mut |deser| {
         413  +
                            container.push(crate::types::CommonPrefix::deserialize(deser)?);
         414  +
                            Ok(())
         415  +
                        })?;
         416  +
                        container
  415    417   
                    });
  416    418   
                }
  417    419   
                Some(11) => {
  418    420   
                    builder.encoding_type = Some(crate::types::EncodingType::from(deser.read_string(member)?.as_str()));
  419    421   
                }
  420    422   
                Some(12) => {
  421    423   
                    builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
  422    424   
                }
         425  +
                Some(13) => {
         426  +
                    builder._request_id = Some(deser.read_string(member)?);
         427  +
                }
         428  +
                _ => {}
         429  +
            }
         430  +
            Ok(())
         431  +
        })?;
         432  +
        Ok(builder.build())
         433  +
    }
         434  +
}
         435  +
impl ListMultipartUploadsOutput {
         436  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         437  +
    /// Header-bound members are read directly from headers, avoiding runtime
         438  +
    /// member iteration overhead. Body members are read via the deserializer.
         439  +
    pub fn deserialize_with_response(
         440  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         441  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         442  +
        _status: u16,
         443  +
        _body: &[u8],
         444  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         445  +
        #[allow(unused_variables, unused_mut)]
         446  +
        let mut builder = Self::builder();
         447  +
        if let Some(val) = headers.get("x-amz-request-charged") {
         448  +
            builder.request_charged = Some(crate::types::RequestCharged::from(val));
         449  +
        }
         450  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         451  +
            builder._request_id = Some(val.to_string());
         452  +
        }
         453  +
        #[allow(
         454  +
            unused_variables,
         455  +
            unreachable_code,
         456  +
            clippy::single_match,
         457  +
            clippy::match_single_binding,
         458  +
            clippy::diverging_sub_expression
         459  +
        )]
         460  +
        deserializer.read_struct(&LISTMULTIPARTUPLOADSOUTPUT_SCHEMA, &mut |member, deser| {
         461  +
            match member.member_index() {
         462  +
                Some(0) => {
         463  +
                    builder.bucket = Some(deser.read_string(member)?);
         464  +
                }
         465  +
                Some(1) => {
         466  +
                    builder.key_marker = Some(deser.read_string(member)?);
         467  +
                }
         468  +
                Some(2) => {
         469  +
                    builder.upload_id_marker = Some(deser.read_string(member)?);
         470  +
                }
         471  +
                Some(3) => {
         472  +
                    builder.next_key_marker = Some(deser.read_string(member)?);
         473  +
                }
         474  +
                Some(4) => {
         475  +
                    builder.prefix = Some(deser.read_string(member)?);
         476  +
                }
         477  +
                Some(5) => {
         478  +
                    builder.delimiter = Some(deser.read_string(member)?);
         479  +
                }
         480  +
                Some(6) => {
         481  +
                    builder.next_upload_id_marker = Some(deser.read_string(member)?);
         482  +
                }
         483  +
                Some(7) => {
         484  +
                    builder.max_uploads = Some(deser.read_integer(member)?);
         485  +
                }
         486  +
                Some(8) => {
         487  +
                    builder.is_truncated = Some(deser.read_boolean(member)?);
         488  +
                }
         489  +
                Some(9) => {
         490  +
                    builder.uploads = Some({
         491  +
                        let mut container = Vec::new();
         492  +
                        deser.read_list(member, &mut |deser| {
         493  +
                            container.push(crate::types::MultipartUpload::deserialize(deser)?);
         494  +
                            Ok(())
         495  +
                        })?;
         496  +
                        container
         497  +
                    });
         498  +
                }
         499  +
                Some(10) => {
         500  +
                    builder.common_prefixes = Some({
         501  +
                        let mut container = Vec::new();
         502  +
                        deser.read_list(member, &mut |deser| {
         503  +
                            container.push(crate::types::CommonPrefix::deserialize(deser)?);
         504  +
                            Ok(())
         505  +
                        })?;
         506  +
                        container
         507  +
                    });
         508  +
                }
         509  +
                Some(11) => {
         510  +
                    builder.encoding_type = Some(crate::types::EncodingType::from(deser.read_string(member)?.as_str()));
         511  +
                }
         512  +
                Some(12) => { /* read from headers above */ }
  423    513   
                _ => {}
  424    514   
            }
  425    515   
            Ok(())
  426    516   
        })?;
  427    517   
        Ok(builder.build())
  428    518   
    }
  429    519   
}
  430    520   
impl crate::s3_request_id::RequestIdExt for ListMultipartUploadsOutput {
  431    521   
    fn extended_request_id(&self) -> Option<&str> {
  432    522   
        self._extended_request_id.as_deref()

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_object_versions.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 `ListObjectVersions`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ListObjectVersions;
    6      6   
impl ListObjectVersions {
    7      7   
    /// Creates a new `ListObjectVersions`
    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::list_object_versions::ListObjectVersionsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::list_object_versions::ListObjectVersionsOutput::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::list_object_versions::ListObjectVersionsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::list_object_versions::ListObjectVersionsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::list_object_versions::ListObjectVersionsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -113,117 +175,180 @@
  133    137   
                                            ::std::borrow::Cow::Owned(transient_errors)
  134    138   
                                            }).build());
  135    139   
  136    140   
        ::std::borrow::Cow::Owned(rcb)
  137    141   
    }
  138    142   
}
  139    143   
  140    144   
#[derive(Debug)]
  141    145   
struct ListObjectVersionsResponseDeserializer;
  142    146   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListObjectVersionsResponseDeserializer {
  143         -
    fn deserialize_nonstreaming(
         147  +
    fn deserialize_nonstreaming_with_config(
  144    148   
        &self,
  145    149   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         150  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  146    151   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  147    152   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  148    153   
        let headers = response.headers();
  149    154   
        let body = response.body().bytes().expect("body loaded");
  150    155   
        #[allow(unused_mut)]
  151    156   
        let mut force_error = false;
  152    157   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  153    158   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  154    159   
            force_error = true;
  155    160   
        }
@@ -393,398 +453,462 @@
  413    418   
            .expect("the config must have a deserializer");
  414    419   
  415    420   
        let parsed = de.deserialize_streaming(&mut http_response);
  416    421   
        let parsed = parsed.unwrap_or_else(|| {
  417    422   
            let http_response = http_response.map(|body| {
  418    423   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  419    424   
                    body.bytes().unwrap(),
  420    425   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  421    426   
                )))
  422    427   
            });
  423         -
            de.deserialize_nonstreaming(&http_response)
         428  +
            // Build a config bag with the protocol for schema-based deserialization
         429  +
            #[allow(unused_mut)]
         430  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         431  +
         432  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  424    433   
        });
  425    434   
        let parsed = parsed
  426    435   
            .expect("should be successful response")
  427    436   
            .downcast::<crate::operation::list_object_versions::ListObjectVersionsOutput>()
  428    437   
            .unwrap();
  429    438   
        ::pretty_assertions::assert_eq!(parsed.is_truncated, expected_output.is_truncated, "Unexpected value for `is_truncated`");
  430    439   
        ::pretty_assertions::assert_eq!(parsed.key_marker, expected_output.key_marker, "Unexpected value for `key_marker`");
  431    440   
        ::pretty_assertions::assert_eq!(
  432    441   
            parsed.version_id_marker,
  433    442   
            expected_output.version_id_marker,

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_object_versions/_list_object_versions_input.rs

@@ -67,67 +356,418 @@
   87     87   
    "com.amazonaws.s3.synthetic",
   88     88   
    "ListObjectVersionsInput",
   89     89   
);
   90     90   
static LISTOBJECTVERSIONSINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.s3.synthetic#ListObjectVersionsInput$Bucket",
   93     93   
        "com.amazonaws.s3.synthetic",
   94     94   
        "ListObjectVersionsInput",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::String,
   97         -
    "bucket",
          97  +
    "Bucket",
   98     98   
    0,
   99     99   
)
  100    100   
.with_http_label();
  101    101   
static LISTOBJECTVERSIONSINPUT_MEMBER_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.s3.synthetic#ListObjectVersionsInput$Delimiter",
  104    104   
        "com.amazonaws.s3.synthetic",
  105    105   
        "ListObjectVersionsInput",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "delimiter",
         108  +
    "Delimiter",
  109    109   
    1,
  110    110   
)
  111    111   
.with_http_query("delimiter");
  112    112   
static LISTOBJECTVERSIONSINPUT_MEMBER_ENCODING_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.s3.synthetic#ListObjectVersionsInput$EncodingType",
  115    115   
        "com.amazonaws.s3.synthetic",
  116    116   
        "ListObjectVersionsInput",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::String,
  119         -
    "encoding_type",
         119  +
    "EncodingType",
  120    120   
    2,
  121    121   
)
  122    122   
.with_http_query("encoding-type");
  123    123   
static LISTOBJECTVERSIONSINPUT_MEMBER_KEY_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.s3.synthetic#ListObjectVersionsInput$KeyMarker",
  126    126   
        "com.amazonaws.s3.synthetic",
  127    127   
        "ListObjectVersionsInput",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::String,
  130         -
    "key_marker",
         130  +
    "KeyMarker",
  131    131   
    3,
  132    132   
)
  133    133   
.with_http_query("key-marker");
  134    134   
static LISTOBJECTVERSIONSINPUT_MEMBER_MAX_KEYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "com.amazonaws.s3.synthetic#ListObjectVersionsInput$MaxKeys",
  137    137   
        "com.amazonaws.s3.synthetic",
  138    138   
        "ListObjectVersionsInput",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::Integer,
  141         -
    "max_keys",
         141  +
    "MaxKeys",
  142    142   
    4,
  143    143   
)
  144    144   
.with_http_query("max-keys");
  145    145   
static LISTOBJECTVERSIONSINPUT_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static(
  147    147   
        "com.amazonaws.s3.synthetic#ListObjectVersionsInput$Prefix",
  148    148   
        "com.amazonaws.s3.synthetic",
  149    149   
        "ListObjectVersionsInput",
  150    150   
    ),
  151    151   
    ::aws_smithy_schema::ShapeType::String,
  152         -
    "prefix",
         152  +
    "Prefix",
  153    153   
    5,
  154    154   
)
  155    155   
.with_http_query("prefix");
  156    156   
static LISTOBJECTVERSIONSINPUT_MEMBER_VERSION_ID_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  157    157   
    ::aws_smithy_schema::ShapeId::from_static(
  158    158   
        "com.amazonaws.s3.synthetic#ListObjectVersionsInput$VersionIdMarker",
  159    159   
        "com.amazonaws.s3.synthetic",
  160    160   
        "ListObjectVersionsInput",
  161    161   
    ),
  162    162   
    ::aws_smithy_schema::ShapeType::String,
  163         -
    "version_id_marker",
         163  +
    "VersionIdMarker",
  164    164   
    6,
  165    165   
)
  166    166   
.with_http_query("version-id-marker");
  167    167   
static LISTOBJECTVERSIONSINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  168    168   
    ::aws_smithy_schema::ShapeId::from_static(
  169    169   
        "com.amazonaws.s3.synthetic#ListObjectVersionsInput$ExpectedBucketOwner",
  170    170   
        "com.amazonaws.s3.synthetic",
  171    171   
        "ListObjectVersionsInput",
  172    172   
    ),
  173    173   
    ::aws_smithy_schema::ShapeType::String,
  174         -
    "expected_bucket_owner",
         174  +
    "ExpectedBucketOwner",
  175    175   
    7,
  176    176   
)
  177    177   
.with_http_header("x-amz-expected-bucket-owner");
  178    178   
static LISTOBJECTVERSIONSINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static(
  180    180   
        "com.amazonaws.s3.synthetic#ListObjectVersionsInput$RequestPayer",
  181    181   
        "com.amazonaws.s3.synthetic",
  182    182   
        "ListObjectVersionsInput",
  183    183   
    ),
  184    184   
    ::aws_smithy_schema::ShapeType::String,
  185         -
    "request_payer",
         185  +
    "RequestPayer",
  186    186   
    8,
  187    187   
)
  188    188   
.with_http_header("x-amz-request-payer");
  189    189   
static LISTOBJECTVERSIONSINPUT_MEMBER_OPTIONAL_OBJECT_ATTRIBUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  190    190   
    ::aws_smithy_schema::ShapeId::from_static(
  191    191   
        "com.amazonaws.s3.synthetic#ListObjectVersionsInput$OptionalObjectAttributes",
  192    192   
        "com.amazonaws.s3.synthetic",
  193    193   
        "ListObjectVersionsInput",
  194    194   
    ),
  195    195   
    ::aws_smithy_schema::ShapeType::List,
  196         -
    "optional_object_attributes",
         196  +
    "OptionalObjectAttributes",
  197    197   
    9,
  198    198   
)
  199    199   
.with_http_header("x-amz-optional-object-attributes");
  200    200   
static LISTOBJECTVERSIONSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  201    201   
    LISTOBJECTVERSIONSINPUT_SCHEMA_ID,
  202    202   
    ::aws_smithy_schema::ShapeType::Structure,
  203    203   
    &[
  204    204   
        &LISTOBJECTVERSIONSINPUT_MEMBER_BUCKET,
  205    205   
        &LISTOBJECTVERSIONSINPUT_MEMBER_DELIMITER,
  206    206   
        &LISTOBJECTVERSIONSINPUT_MEMBER_ENCODING_TYPE,
  207    207   
        &LISTOBJECTVERSIONSINPUT_MEMBER_KEY_MARKER,
  208    208   
        &LISTOBJECTVERSIONSINPUT_MEMBER_MAX_KEYS,
  209    209   
        &LISTOBJECTVERSIONSINPUT_MEMBER_PREFIX,
  210    210   
        &LISTOBJECTVERSIONSINPUT_MEMBER_VERSION_ID_MARKER,
  211    211   
        &LISTOBJECTVERSIONSINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
  212    212   
        &LISTOBJECTVERSIONSINPUT_MEMBER_REQUEST_PAYER,
  213    213   
        &LISTOBJECTVERSIONSINPUT_MEMBER_OPTIONAL_OBJECT_ATTRIBUTES,
  214    214   
    ],
  215         -
);
         215  +
)
         216  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/?versions", None));
  216    217   
impl ListObjectVersionsInput {
  217    218   
    /// The schema for this shape.
  218    219   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTOBJECTVERSIONSINPUT_SCHEMA;
  219    220   
}
  220    221   
impl ::aws_smithy_schema::serde::SerializableStruct for ListObjectVersionsInput {
  221    222   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  222    223   
    fn serialize_members(
  223    224   
        &self,
  224    225   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  225    226   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  226    227   
        if let Some(ref val) = self.bucket {
  227    228   
            ser.write_string(&LISTOBJECTVERSIONSINPUT_MEMBER_BUCKET, val)?;
  228    229   
        }
  229    230   
        if let Some(ref val) = self.delimiter {
  230    231   
            ser.write_string(&LISTOBJECTVERSIONSINPUT_MEMBER_DELIMITER, val)?;
  231    232   
        }
  232    233   
        if let Some(ref val) = self.encoding_type {
  233    234   
            ser.write_string(&LISTOBJECTVERSIONSINPUT_MEMBER_ENCODING_TYPE, val.as_str())?;
  234    235   
        }
  235    236   
        if let Some(ref val) = self.key_marker {
  236    237   
            ser.write_string(&LISTOBJECTVERSIONSINPUT_MEMBER_KEY_MARKER, val)?;
  237    238   
        }
  238    239   
        if let Some(ref val) = self.max_keys {
  239    240   
            ser.write_integer(&LISTOBJECTVERSIONSINPUT_MEMBER_MAX_KEYS, *val)?;
  240    241   
        }
  241    242   
        if let Some(ref val) = self.prefix {
  242    243   
            ser.write_string(&LISTOBJECTVERSIONSINPUT_MEMBER_PREFIX, val)?;
  243    244   
        }
  244    245   
        if let Some(ref val) = self.version_id_marker {
  245    246   
            ser.write_string(&LISTOBJECTVERSIONSINPUT_MEMBER_VERSION_ID_MARKER, val)?;
  246    247   
        }
  247    248   
        if let Some(ref val) = self.expected_bucket_owner {
  248    249   
            ser.write_string(&LISTOBJECTVERSIONSINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
  249    250   
        }
  250    251   
        if let Some(ref val) = self.request_payer {
  251    252   
            ser.write_string(&LISTOBJECTVERSIONSINPUT_MEMBER_REQUEST_PAYER, val.as_str())?;
  252    253   
        }
  253    254   
        if let Some(ref val) = self.optional_object_attributes {
  254    255   
            ser.write_list(
  255    256   
                &LISTOBJECTVERSIONSINPUT_MEMBER_OPTIONAL_OBJECT_ATTRIBUTES,
  256    257   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  257    258   
                    for item in val {
  258    259   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
  259    260   
                    }
  260    261   
                    Ok(())
  261    262   
                },
  262    263   
            )?;
  263    264   
        }
  264    265   
        Ok(())
  265    266   
    }
  266    267   
}
  267    268   
impl ListObjectVersionsInput {
  268    269   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  269         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  270         -
        deserializer: &mut D,
         270  +
    pub fn deserialize(
         271  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  271    272   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  272    273   
        #[allow(unused_variables, unused_mut)]
  273    274   
        let mut builder = Self::builder();
  274    275   
        #[allow(
  275    276   
            unused_variables,
  276    277   
            unreachable_code,
  277    278   
            clippy::single_match,
  278    279   
            clippy::match_single_binding,
  279    280   
            clippy::diverging_sub_expression
  280    281   
        )]
  281         -
        deserializer.read_struct(&LISTOBJECTVERSIONSINPUT_SCHEMA, (), |_, member, deser| {
         282  +
        deserializer.read_struct(&LISTOBJECTVERSIONSINPUT_SCHEMA, &mut |member, deser| {
  282    283   
            match member.member_index() {
  283    284   
                Some(0) => {
  284    285   
                    builder.bucket = Some(deser.read_string(member)?);
  285    286   
                }
  286    287   
                Some(1) => {
  287    288   
                    builder.delimiter = Some(deser.read_string(member)?);
  288    289   
                }
  289    290   
                Some(2) => {
  290    291   
                    builder.encoding_type = Some(crate::types::EncodingType::from(deser.read_string(member)?.as_str()));
  291    292   
                }
  292    293   
                Some(3) => {
  293    294   
                    builder.key_marker = Some(deser.read_string(member)?);
  294    295   
                }
  295    296   
                Some(4) => {
  296    297   
                    builder.max_keys = Some(deser.read_integer(member)?);
  297    298   
                }
  298    299   
                Some(5) => {
  299    300   
                    builder.prefix = Some(deser.read_string(member)?);
  300    301   
                }
  301    302   
                Some(6) => {
  302    303   
                    builder.version_id_marker = Some(deser.read_string(member)?);
  303    304   
                }
  304    305   
                Some(7) => {
  305    306   
                    builder.expected_bucket_owner = Some(deser.read_string(member)?);
  306    307   
                }
  307    308   
                Some(8) => {
  308    309   
                    builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
  309    310   
                }
  310    311   
                Some(9) => {
  311    312   
                    builder.optional_object_attributes = Some({
  312         -
                        let container = if let Some(cap) = deser.container_size() {
  313         -
                            Vec::with_capacity(cap)
  314         -
                        } else {
  315         -
                            Vec::new()
  316         -
                        };
  317         -
                        deser.read_list(member, container, |mut list, deser| {
  318         -
                            list.push(crate::types::OptionalObjectAttributes::from(deser.read_string(member)?.as_str()));
  319         -
                            Ok(list)
  320         -
                        })?
         313  +
                        let mut container = Vec::new();
         314  +
                        deser.read_list(member, &mut |deser| {
         315  +
                            container.push(crate::types::OptionalObjectAttributes::from(deser.read_string(member)?.as_str()));
         316  +
                            Ok(())
         317  +
                        })?;
         318  +
                        container
  321    319   
                    });
  322    320   
                }
  323    321   
                _ => {}
  324    322   
            }
  325    323   
            Ok(())
  326    324   
        })?;
         325  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         326  +
        builder
         327  +
            .build()
         328  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         329  +
    }
         330  +
}
         331  +
impl ListObjectVersionsInput {
         332  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         333  +
    /// Header-bound members are read directly from headers, avoiding runtime
         334  +
    /// member iteration overhead. Body members are read via the deserializer.
         335  +
    pub fn deserialize_with_response(
         336  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         337  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         338  +
        _status: u16,
         339  +
        _body: &[u8],
         340  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         341  +
        #[allow(unused_variables, unused_mut)]
         342  +
        let mut builder = Self::builder();
         343  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         344  +
            builder.expected_bucket_owner = Some(val.to_string());
         345  +
        }
         346  +
        if let Some(val) = headers.get("x-amz-request-payer") {
         347  +
            builder.request_payer = Some(crate::types::RequestPayer::from(val));
         348  +
        }
         349  +
        if let Some(val) = headers.get("x-amz-optional-object-attributes") {
         350  +
            builder.optional_object_attributes = Some(val.split(',').map(|s| crate::types::OptionalObjectAttributes::from(s.trim())).collect());
         351  +
        }
         352  +
        #[allow(
         353  +
            unused_variables,
         354  +
            unreachable_code,
         355  +
            clippy::single_match,
         356  +
            clippy::match_single_binding,
         357  +
            clippy::diverging_sub_expression
         358  +
        )]
         359  +
        deserializer.read_struct(&LISTOBJECTVERSIONSINPUT_SCHEMA, &mut |member, deser| {
         360  +
            match member.member_index() {
         361  +
                Some(0) => {
         362  +
                    builder.bucket = Some(deser.read_string(member)?);
         363  +
                }
         364  +
                Some(1) => {
         365  +
                    builder.delimiter = Some(deser.read_string(member)?);
         366  +
                }
         367  +
                Some(2) => {
         368  +
                    builder.encoding_type = Some(crate::types::EncodingType::from(deser.read_string(member)?.as_str()));
         369  +
                }
         370  +
                Some(3) => {
         371  +
                    builder.key_marker = Some(deser.read_string(member)?);
         372  +
                }
         373  +
                Some(4) => {
         374  +
                    builder.max_keys = Some(deser.read_integer(member)?);
         375  +
                }
         376  +
                Some(5) => {
         377  +
                    builder.prefix = Some(deser.read_string(member)?);
         378  +
                }
         379  +
                Some(6) => {
         380  +
                    builder.version_id_marker = Some(deser.read_string(member)?);
         381  +
                }
         382  +
                Some(7) => { /* read from headers above */ }
         383  +
                Some(8) => { /* read from headers above */ }
         384  +
                Some(9) => { /* read from headers above */ }
         385  +
                _ => {}
         386  +
            }
         387  +
            Ok(())
         388  +
        })?;
  327    389   
        builder
  328    390   
            .build()
  329    391   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  330    392   
    }
  331    393   
}
  332    394   
impl ListObjectVersionsInput {
  333    395   
    /// Creates a new builder-style object to manufacture [`ListObjectVersionsInput`](crate::operation::list_object_versions::ListObjectVersionsInput).
  334    396   
    pub fn builder() -> crate::operation::list_object_versions::builders::ListObjectVersionsInputBuilder {
  335    397   
        crate::operation::list_object_versions::builders::ListObjectVersionsInputBuilder::default()
  336    398   
    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_object_versions/_list_object_versions_output.rs

@@ -91,91 +307,315 @@
  111    111   
    "com.amazonaws.s3.synthetic",
  112    112   
    "ListObjectVersionsOutput",
  113    113   
);
  114    114   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_IS_TRUNCATED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$IsTruncated",
  117    117   
        "com.amazonaws.s3.synthetic",
  118    118   
        "ListObjectVersionsOutput",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::Boolean,
  121         -
    "is_truncated",
         121  +
    "IsTruncated",
  122    122   
    0,
  123    123   
);
  124    124   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_KEY_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static(
  126    126   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$KeyMarker",
  127    127   
        "com.amazonaws.s3.synthetic",
  128    128   
        "ListObjectVersionsOutput",
  129    129   
    ),
  130    130   
    ::aws_smithy_schema::ShapeType::String,
  131         -
    "key_marker",
         131  +
    "KeyMarker",
  132    132   
    1,
  133    133   
);
  134    134   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_VERSION_ID_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$VersionIdMarker",
  137    137   
        "com.amazonaws.s3.synthetic",
  138    138   
        "ListObjectVersionsOutput",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::String,
  141         -
    "version_id_marker",
         141  +
    "VersionIdMarker",
  142    142   
    2,
  143    143   
);
  144    144   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_NEXT_KEY_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$NextKeyMarker",
  147    147   
        "com.amazonaws.s3.synthetic",
  148    148   
        "ListObjectVersionsOutput",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::String,
  151         -
    "next_key_marker",
         151  +
    "NextKeyMarker",
  152    152   
    3,
  153    153   
);
  154    154   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_NEXT_VERSION_ID_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  155    155   
    ::aws_smithy_schema::ShapeId::from_static(
  156    156   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$NextVersionIdMarker",
  157    157   
        "com.amazonaws.s3.synthetic",
  158    158   
        "ListObjectVersionsOutput",
  159    159   
    ),
  160    160   
    ::aws_smithy_schema::ShapeType::String,
  161         -
    "next_version_id_marker",
         161  +
    "NextVersionIdMarker",
  162    162   
    4,
  163    163   
);
  164    164   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_VERSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  165    165   
    ::aws_smithy_schema::ShapeId::from_static(
  166    166   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$Versions",
  167    167   
        "com.amazonaws.s3.synthetic",
  168    168   
        "ListObjectVersionsOutput",
  169    169   
    ),
  170    170   
    ::aws_smithy_schema::ShapeType::List,
  171         -
    "versions",
         171  +
    "Versions",
  172    172   
    5,
  173    173   
)
  174    174   
.with_xml_name("Version")
  175    175   
.with_xml_flattened();
  176    176   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_DELETE_MARKERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  177    177   
    ::aws_smithy_schema::ShapeId::from_static(
  178    178   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$DeleteMarkers",
  179    179   
        "com.amazonaws.s3.synthetic",
  180    180   
        "ListObjectVersionsOutput",
  181    181   
    ),
  182    182   
    ::aws_smithy_schema::ShapeType::List,
  183         -
    "delete_markers",
         183  +
    "DeleteMarkers",
  184    184   
    6,
  185    185   
)
  186    186   
.with_xml_name("DeleteMarker")
  187    187   
.with_xml_flattened();
  188    188   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  189    189   
    ::aws_smithy_schema::ShapeId::from_static(
  190    190   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$Name",
  191    191   
        "com.amazonaws.s3.synthetic",
  192    192   
        "ListObjectVersionsOutput",
  193    193   
    ),
  194    194   
    ::aws_smithy_schema::ShapeType::String,
  195         -
    "name",
         195  +
    "Name",
  196    196   
    7,
  197    197   
);
  198    198   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  199    199   
    ::aws_smithy_schema::ShapeId::from_static(
  200    200   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$Prefix",
  201    201   
        "com.amazonaws.s3.synthetic",
  202    202   
        "ListObjectVersionsOutput",
  203    203   
    ),
  204    204   
    ::aws_smithy_schema::ShapeType::String,
  205         -
    "prefix",
         205  +
    "Prefix",
  206    206   
    8,
  207    207   
);
  208    208   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  209    209   
    ::aws_smithy_schema::ShapeId::from_static(
  210    210   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$Delimiter",
  211    211   
        "com.amazonaws.s3.synthetic",
  212    212   
        "ListObjectVersionsOutput",
  213    213   
    ),
  214    214   
    ::aws_smithy_schema::ShapeType::String,
  215         -
    "delimiter",
         215  +
    "Delimiter",
  216    216   
    9,
  217    217   
);
  218    218   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_MAX_KEYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  219    219   
    ::aws_smithy_schema::ShapeId::from_static(
  220    220   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$MaxKeys",
  221    221   
        "com.amazonaws.s3.synthetic",
  222    222   
        "ListObjectVersionsOutput",
  223    223   
    ),
  224    224   
    ::aws_smithy_schema::ShapeType::Integer,
  225         -
    "max_keys",
         225  +
    "MaxKeys",
  226    226   
    10,
  227    227   
);
  228    228   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_COMMON_PREFIXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  229    229   
    ::aws_smithy_schema::ShapeId::from_static(
  230    230   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$CommonPrefixes",
  231    231   
        "com.amazonaws.s3.synthetic",
  232    232   
        "ListObjectVersionsOutput",
  233    233   
    ),
  234    234   
    ::aws_smithy_schema::ShapeType::List,
  235         -
    "common_prefixes",
         235  +
    "CommonPrefixes",
  236    236   
    11,
  237    237   
)
  238    238   
.with_xml_flattened();
  239    239   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_ENCODING_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  240    240   
    ::aws_smithy_schema::ShapeId::from_static(
  241    241   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$EncodingType",
  242    242   
        "com.amazonaws.s3.synthetic",
  243    243   
        "ListObjectVersionsOutput",
  244    244   
    ),
  245    245   
    ::aws_smithy_schema::ShapeType::String,
  246         -
    "encoding_type",
         246  +
    "EncodingType",
  247    247   
    12,
  248    248   
);
  249    249   
static LISTOBJECTVERSIONSOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  250    250   
    ::aws_smithy_schema::ShapeId::from_static(
  251    251   
        "com.amazonaws.s3.synthetic#ListObjectVersionsOutput$RequestCharged",
  252    252   
        "com.amazonaws.s3.synthetic",
  253    253   
        "ListObjectVersionsOutput",
  254    254   
    ),
  255    255   
    ::aws_smithy_schema::ShapeType::String,
  256         -
    "request_charged",
         256  +
    "RequestCharged",
  257    257   
    13,
  258    258   
)
  259    259   
.with_http_header("x-amz-request-charged");
         260  +
static LISTOBJECTVERSIONSOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         261  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         262  +
    ::aws_smithy_schema::ShapeType::String,
         263  +
    "request_id",
         264  +
    14,
         265  +
)
         266  +
.with_http_header("x-amzn-requestid");
  260    267   
static LISTOBJECTVERSIONSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  261    268   
    LISTOBJECTVERSIONSOUTPUT_SCHEMA_ID,
  262    269   
    ::aws_smithy_schema::ShapeType::Structure,
  263    270   
    &[
  264    271   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_IS_TRUNCATED,
  265    272   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_KEY_MARKER,
  266    273   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_VERSION_ID_MARKER,
  267    274   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_NEXT_KEY_MARKER,
  268    275   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_NEXT_VERSION_ID_MARKER,
  269    276   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_VERSIONS,
  270    277   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_DELETE_MARKERS,
  271    278   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_NAME,
  272    279   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_PREFIX,
  273    280   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_DELIMITER,
  274    281   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_MAX_KEYS,
  275    282   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_COMMON_PREFIXES,
  276    283   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_ENCODING_TYPE,
  277    284   
        &LISTOBJECTVERSIONSOUTPUT_MEMBER_REQUEST_CHARGED,
         285  +
        &LISTOBJECTVERSIONSOUTPUT_MEMBER__REQUEST_ID,
  278    286   
    ],
  279    287   
)
  280    288   
.with_xml_name("ListVersionsResult");
  281    289   
impl ListObjectVersionsOutput {
  282    290   
    /// The schema for this shape.
  283    291   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTOBJECTVERSIONSOUTPUT_SCHEMA;
  284    292   
}
  285    293   
impl ::aws_smithy_schema::serde::SerializableStruct for ListObjectVersionsOutput {
  286    294   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  287    295   
    fn serialize_members(
@@ -332,340 +477,574 @@
  352    360   
            ser.write_string(&LISTOBJECTVERSIONSOUTPUT_MEMBER_ENCODING_TYPE, val.as_str())?;
  353    361   
        }
  354    362   
        if let Some(ref val) = self.request_charged {
  355    363   
            ser.write_string(&LISTOBJECTVERSIONSOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
  356    364   
        }
  357    365   
        Ok(())
  358    366   
    }
  359    367   
}
  360    368   
impl ListObjectVersionsOutput {
  361    369   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  362         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  363         -
        deserializer: &mut D,
         370  +
    pub fn deserialize(
         371  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  364    372   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  365    373   
        #[allow(unused_variables, unused_mut)]
  366    374   
        let mut builder = Self::builder();
  367    375   
        #[allow(
  368    376   
            unused_variables,
  369    377   
            unreachable_code,
  370    378   
            clippy::single_match,
  371    379   
            clippy::match_single_binding,
  372    380   
            clippy::diverging_sub_expression
  373    381   
        )]
  374         -
        deserializer.read_struct(&LISTOBJECTVERSIONSOUTPUT_SCHEMA, (), |_, member, deser| {
         382  +
        deserializer.read_struct(&LISTOBJECTVERSIONSOUTPUT_SCHEMA, &mut |member, deser| {
  375    383   
            match member.member_index() {
  376    384   
                Some(0) => {
  377    385   
                    builder.is_truncated = Some(deser.read_boolean(member)?);
  378    386   
                }
  379    387   
                Some(1) => {
  380    388   
                    builder.key_marker = Some(deser.read_string(member)?);
  381    389   
                }
  382    390   
                Some(2) => {
  383    391   
                    builder.version_id_marker = Some(deser.read_string(member)?);
  384    392   
                }
  385    393   
                Some(3) => {
  386    394   
                    builder.next_key_marker = Some(deser.read_string(member)?);
  387    395   
                }
  388    396   
                Some(4) => {
  389    397   
                    builder.next_version_id_marker = Some(deser.read_string(member)?);
  390    398   
                }
  391    399   
                Some(5) => {
  392    400   
                    builder.versions = Some({
  393         -
                        let container = if let Some(cap) = deser.container_size() {
  394         -
                            Vec::with_capacity(cap)
  395         -
                        } else {
  396         -
                            Vec::new()
  397         -
                        };
  398         -
                        deser.read_list(member, container, |mut list, deser| {
  399         -
                            list.push(crate::types::ObjectVersion::deserialize(deser)?);
  400         -
                            Ok(list)
  401         -
                        })?
         401  +
                        let mut container = Vec::new();
         402  +
                        deser.read_list(member, &mut |deser| {
         403  +
                            container.push(crate::types::ObjectVersion::deserialize(deser)?);
         404  +
                            Ok(())
         405  +
                        })?;
         406  +
                        container
  402    407   
                    });
  403    408   
                }
  404    409   
                Some(6) => {
  405    410   
                    builder.delete_markers = Some({
  406         -
                        let container = if let Some(cap) = deser.container_size() {
  407         -
                            Vec::with_capacity(cap)
  408         -
                        } else {
  409         -
                            Vec::new()
  410         -
                        };
  411         -
                        deser.read_list(member, container, |mut list, deser| {
  412         -
                            list.push(crate::types::DeleteMarkerEntry::deserialize(deser)?);
  413         -
                            Ok(list)
  414         -
                        })?
         411  +
                        let mut container = Vec::new();
         412  +
                        deser.read_list(member, &mut |deser| {
         413  +
                            container.push(crate::types::DeleteMarkerEntry::deserialize(deser)?);
         414  +
                            Ok(())
         415  +
                        })?;
         416  +
                        container
  415    417   
                    });
  416    418   
                }
  417    419   
                Some(7) => {
  418    420   
                    builder.name = Some(deser.read_string(member)?);
  419    421   
                }
  420    422   
                Some(8) => {
  421    423   
                    builder.prefix = Some(deser.read_string(member)?);
  422    424   
                }
  423    425   
                Some(9) => {
  424    426   
                    builder.delimiter = Some(deser.read_string(member)?);
  425    427   
                }
  426    428   
                Some(10) => {
  427    429   
                    builder.max_keys = Some(deser.read_integer(member)?);
  428    430   
                }
  429    431   
                Some(11) => {
  430    432   
                    builder.common_prefixes = Some({
  431         -
                        let container = if let Some(cap) = deser.container_size() {
  432         -
                            Vec::with_capacity(cap)
  433         -
                        } else {
  434         -
                            Vec::new()
  435         -
                        };
  436         -
                        deser.read_list(member, container, |mut list, deser| {
  437         -
                            list.push(crate::types::CommonPrefix::deserialize(deser)?);
  438         -
                            Ok(list)
  439         -
                        })?
         433  +
                        let mut container = Vec::new();
         434  +
                        deser.read_list(member, &mut |deser| {
         435  +
                            container.push(crate::types::CommonPrefix::deserialize(deser)?);
         436  +
                            Ok(())
         437  +
                        })?;
         438  +
                        container
  440    439   
                    });
  441    440   
                }
  442    441   
                Some(12) => {
  443    442   
                    builder.encoding_type = Some(crate::types::EncodingType::from(deser.read_string(member)?.as_str()));
  444    443   
                }
  445    444   
                Some(13) => {
  446    445   
                    builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
  447    446   
                }
         447  +
                Some(14) => {
         448  +
                    builder._request_id = Some(deser.read_string(member)?);
         449  +
                }
         450  +
                _ => {}
         451  +
            }
         452  +
            Ok(())
         453  +
        })?;
         454  +
        Ok(builder.build())
         455  +
    }
         456  +
}
         457  +
impl ListObjectVersionsOutput {
         458  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         459  +
    /// Header-bound members are read directly from headers, avoiding runtime
         460  +
    /// member iteration overhead. Body members are read via the deserializer.
         461  +
    pub fn deserialize_with_response(
         462  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         463  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         464  +
        _status: u16,
         465  +
        _body: &[u8],
         466  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         467  +
        #[allow(unused_variables, unused_mut)]
         468  +
        let mut builder = Self::builder();
         469  +
        if let Some(val) = headers.get("x-amz-request-charged") {
         470  +
            builder.request_charged = Some(crate::types::RequestCharged::from(val));
         471  +
        }
         472  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         473  +
            builder._request_id = Some(val.to_string());
         474  +
        }
         475  +
        #[allow(
         476  +
            unused_variables,
         477  +
            unreachable_code,
         478  +
            clippy::single_match,
         479  +
            clippy::match_single_binding,
         480  +
            clippy::diverging_sub_expression
         481  +
        )]
         482  +
        deserializer.read_struct(&LISTOBJECTVERSIONSOUTPUT_SCHEMA, &mut |member, deser| {
         483  +
            match member.member_index() {
         484  +
                Some(0) => {
         485  +
                    builder.is_truncated = Some(deser.read_boolean(member)?);
         486  +
                }
         487  +
                Some(1) => {
         488  +
                    builder.key_marker = Some(deser.read_string(member)?);
         489  +
                }
         490  +
                Some(2) => {
         491  +
                    builder.version_id_marker = Some(deser.read_string(member)?);
         492  +
                }
         493  +
                Some(3) => {
         494  +
                    builder.next_key_marker = Some(deser.read_string(member)?);
         495  +
                }
         496  +
                Some(4) => {
         497  +
                    builder.next_version_id_marker = Some(deser.read_string(member)?);
         498  +
                }
         499  +
                Some(5) => {
         500  +
                    builder.versions = Some({
         501  +
                        let mut container = Vec::new();
         502  +
                        deser.read_list(member, &mut |deser| {
         503  +
                            container.push(crate::types::ObjectVersion::deserialize(deser)?);
         504  +
                            Ok(())
         505  +
                        })?;
         506  +
                        container
         507  +
                    });
         508  +
                }
         509  +
                Some(6) => {
         510  +
                    builder.delete_markers = Some({
         511  +
                        let mut container = Vec::new();
         512  +
                        deser.read_list(member, &mut |deser| {
         513  +
                            container.push(crate::types::DeleteMarkerEntry::deserialize(deser)?);
         514  +
                            Ok(())
         515  +
                        })?;
         516  +
                        container
         517  +
                    });
         518  +
                }
         519  +
                Some(7) => {
         520  +
                    builder.name = Some(deser.read_string(member)?);
         521  +
                }
         522  +
                Some(8) => {
         523  +
                    builder.prefix = Some(deser.read_string(member)?);
         524  +
                }
         525  +
                Some(9) => {
         526  +
                    builder.delimiter = Some(deser.read_string(member)?);
         527  +
                }
         528  +
                Some(10) => {
         529  +
                    builder.max_keys = Some(deser.read_integer(member)?);
         530  +
                }
         531  +
                Some(11) => {
         532  +
                    builder.common_prefixes = Some({
         533  +
                        let mut container = Vec::new();
         534  +
                        deser.read_list(member, &mut |deser| {
         535  +
                            container.push(crate::types::CommonPrefix::deserialize(deser)?);
         536  +
                            Ok(())
         537  +
                        })?;
         538  +
                        container
         539  +
                    });
         540  +
                }
         541  +
                Some(12) => {
         542  +
                    builder.encoding_type = Some(crate::types::EncodingType::from(deser.read_string(member)?.as_str()));
         543  +
                }
         544  +
                Some(13) => { /* read from headers above */ }
  448    545   
                _ => {}
  449    546   
            }
  450    547   
            Ok(())
  451    548   
        })?;
  452    549   
        Ok(builder.build())
  453    550   
    }
  454    551   
}
  455    552   
impl crate::s3_request_id::RequestIdExt for ListObjectVersionsOutput {
  456    553   
    fn extended_request_id(&self) -> Option<&str> {
  457    554   
        self._extended_request_id.as_deref()