AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406

Files changed:

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_acl/_get_bucket_acl_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_analytics_configuration.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 `GetBucketAnalyticsConfiguration`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetBucketAnalyticsConfiguration;
    6      6   
impl GetBucketAnalyticsConfiguration {
    7      7   
    /// Creates a new `GetBucketAnalyticsConfiguration`
    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::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationOutput::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::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationError,
   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 GetBucketAnalyticsConfigurationResponseDeserializer;
  161    167   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketAnalyticsConfigurationResponseDeserializer {
  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/get_bucket_analytics_configuration/_get_bucket_analytics_configuration_input.rs

@@ -9,9 +154,201 @@
   29     29   
    "com.amazonaws.s3.synthetic",
   30     30   
    "GetBucketAnalyticsConfigurationInput",
   31     31   
);
   32     32   
static GETBUCKETANALYTICSCONFIGURATIONINPUT_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#GetBucketAnalyticsConfigurationInput$Bucket",
   35     35   
        "com.amazonaws.s3.synthetic",
   36     36   
        "GetBucketAnalyticsConfigurationInput",
   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 GETBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.s3.synthetic#GetBucketAnalyticsConfigurationInput$Id",
   46     46   
        "com.amazonaws.s3.synthetic",
   47     47   
        "GetBucketAnalyticsConfigurationInput",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "id",
          50  +
    "Id",
   51     51   
    1,
   52     52   
)
   53     53   
.with_http_query("id");
   54     54   
static GETBUCKETANALYTICSCONFIGURATIONINPUT_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#GetBucketAnalyticsConfigurationInput$ExpectedBucketOwner",
   57     57   
        "com.amazonaws.s3.synthetic",
   58     58   
        "GetBucketAnalyticsConfigurationInput",
   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 GETBUCKETANALYTICSCONFIGURATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   66     66   
    GETBUCKETANALYTICSCONFIGURATIONINPUT_SCHEMA_ID,
   67     67   
    ::aws_smithy_schema::ShapeType::Structure,
   68     68   
    &[
   69     69   
        &GETBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_BUCKET,
   70     70   
        &GETBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_ID,
   71     71   
        &GETBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
   72     72   
    ],
   73         -
);
          73  +
)
          74  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
          75  +
    "GET",
          76  +
    "/?analytics&x-id=GetBucketAnalyticsConfiguration",
          77  +
    None,
          78  +
));
   74     79   
impl GetBucketAnalyticsConfigurationInput {
   75     80   
    /// The schema for this shape.
   76     81   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETBUCKETANALYTICSCONFIGURATIONINPUT_SCHEMA;
   77     82   
}
   78     83   
impl ::aws_smithy_schema::serde::SerializableStruct for GetBucketAnalyticsConfigurationInput {
   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(&GETBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_BUCKET, val)?;
   86     91   
        }
   87     92   
        if let Some(ref val) = self.id {
   88     93   
            ser.write_string(&GETBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_ID, val)?;
   89     94   
        }
   90     95   
        if let Some(ref val) = self.expected_bucket_owner {
   91     96   
            ser.write_string(&GETBUCKETANALYTICSCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
   92     97   
        }
   93     98   
        Ok(())
   94     99   
    }
   95    100   
}
   96    101   
impl GetBucketAnalyticsConfigurationInput {
   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(&GETBUCKETANALYTICSCONFIGURATIONINPUT_SCHEMA, (), |_, member, deser| {
         115  +
        deserializer.read_struct(&GETBUCKETANALYTICSCONFIGURATIONINPUT_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.id = 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.id = builder.id.or(Some(String::new()));
         132  +
        builder
         133  +
            .build()
         134  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         135  +
    }
         136  +
}
         137  +
impl GetBucketAnalyticsConfigurationInput {
         138  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         139  +
    /// Header-bound members are read directly from headers, avoiding runtime
         140  +
    /// member iteration overhead. Body members are read via the deserializer.
         141  +
    pub fn deserialize_with_response(
         142  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         143  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         144  +
        _status: u16,
         145  +
        _body: &[u8],
         146  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         147  +
        #[allow(unused_variables, unused_mut)]
         148  +
        let mut builder = Self::builder();
         149  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         150  +
            builder.expected_bucket_owner = Some(val.to_string());
         151  +
        }
         152  +
        #[allow(
         153  +
            unused_variables,
         154  +
            unreachable_code,
         155  +
            clippy::single_match,
         156  +
            clippy::match_single_binding,
         157  +
            clippy::diverging_sub_expression
         158  +
        )]
         159  +
        deserializer.read_struct(&GETBUCKETANALYTICSCONFIGURATIONINPUT_SCHEMA, &mut |member, deser| {
         160  +
            match member.member_index() {
         161  +
                Some(0) => {
         162  +
                    builder.bucket = Some(deser.read_string(member)?);
         163  +
                }
         164  +
                Some(1) => {
         165  +
                    builder.id = Some(deser.read_string(member)?);
         166  +
                }
         167  +
                Some(2) => { /* read from headers above */ }
         168  +
                _ => {}
         169  +
            }
         170  +
            Ok(())
         171  +
        })?;
  125    172   
        builder
  126    173   
            .build()
  127    174   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  128    175   
    }
  129    176   
}
  130    177   
impl GetBucketAnalyticsConfigurationInput {
  131    178   
    /// Creates a new builder-style object to manufacture [`GetBucketAnalyticsConfigurationInput`](crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationInput).
  132    179   
    pub fn builder() -> crate::operation::get_bucket_analytics_configuration::builders::GetBucketAnalyticsConfigurationInputBuilder {
  133    180   
        crate::operation::get_bucket_analytics_configuration::builders::GetBucketAnalyticsConfigurationInputBuilder::default()
  134    181   
    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_analytics_configuration/_get_bucket_analytics_configuration_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_cors.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 `GetBucketCors`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetBucketCors;
    6      6   
impl GetBucketCors {
    7      7   
    /// Creates a new `GetBucketCors`
    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::get_bucket_cors::GetBucketCorsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_bucket_cors::GetBucketCorsOutput::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::get_bucket_cors::GetBucketCorsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_bucket_cors::GetBucketCorsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_bucket_cors::GetBucketCorsError,
   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 GetBucketCorsResponseDeserializer;
  150    154   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketCorsResponseDeserializer {
  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/get_bucket_cors/_get_bucket_cors_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_cors/_get_bucket_cors_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_encryption/_get_bucket_encryption_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_encryption/_get_bucket_encryption_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_intelligent_tiering_configuration.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 `GetBucketIntelligentTieringConfiguration`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetBucketIntelligentTieringConfiguration;
    6      6   
impl GetBucketIntelligentTieringConfiguration {
    7      7   
    /// Creates a new `GetBucketIntelligentTieringConfiguration`
    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::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationOutput::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::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationError,
   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 GetBucketIntelligentTieringConfigurationResponseDeserializer;
  161    167   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketIntelligentTieringConfigurationResponseDeserializer {
  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/get_bucket_intelligent_tiering_configuration/_get_bucket_intelligent_tiering_configuration_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_intelligent_tiering_configuration/_get_bucket_intelligent_tiering_configuration_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_inventory_configuration/_get_bucket_inventory_configuration_input.rs

@@ -9,9 +154,201 @@
   29     29   
    "com.amazonaws.s3.synthetic",
   30     30   
    "GetBucketInventoryConfigurationInput",
   31     31   
);
   32     32   
static GETBUCKETINVENTORYCONFIGURATIONINPUT_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#GetBucketInventoryConfigurationInput$Bucket",
   35     35   
        "com.amazonaws.s3.synthetic",
   36     36   
        "GetBucketInventoryConfigurationInput",
   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 GETBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.s3.synthetic#GetBucketInventoryConfigurationInput$Id",
   46     46   
        "com.amazonaws.s3.synthetic",
   47     47   
        "GetBucketInventoryConfigurationInput",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "id",
          50  +
    "Id",
   51     51   
    1,
   52     52   
)
   53     53   
.with_http_query("id");
   54     54   
static GETBUCKETINVENTORYCONFIGURATIONINPUT_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#GetBucketInventoryConfigurationInput$ExpectedBucketOwner",
   57     57   
        "com.amazonaws.s3.synthetic",
   58     58   
        "GetBucketInventoryConfigurationInput",
   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 GETBUCKETINVENTORYCONFIGURATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   66     66   
    GETBUCKETINVENTORYCONFIGURATIONINPUT_SCHEMA_ID,
   67     67   
    ::aws_smithy_schema::ShapeType::Structure,
   68     68   
    &[
   69     69   
        &GETBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_BUCKET,
   70     70   
        &GETBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_ID,
   71     71   
        &GETBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
   72     72   
    ],
   73         -
);
          73  +
)
          74  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
          75  +
    "GET",
          76  +
    "/?inventory&x-id=GetBucketInventoryConfiguration",
          77  +
    None,
          78  +
));
   74     79   
impl GetBucketInventoryConfigurationInput {
   75     80   
    /// The schema for this shape.
   76     81   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETBUCKETINVENTORYCONFIGURATIONINPUT_SCHEMA;
   77     82   
}
   78     83   
impl ::aws_smithy_schema::serde::SerializableStruct for GetBucketInventoryConfigurationInput {
   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(&GETBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_BUCKET, val)?;
   86     91   
        }
   87     92   
        if let Some(ref val) = self.id {
   88     93   
            ser.write_string(&GETBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_ID, val)?;
   89     94   
        }
   90     95   
        if let Some(ref val) = self.expected_bucket_owner {
   91     96   
            ser.write_string(&GETBUCKETINVENTORYCONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
   92     97   
        }
   93     98   
        Ok(())
   94     99   
    }
   95    100   
}
   96    101   
impl GetBucketInventoryConfigurationInput {
   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(&GETBUCKETINVENTORYCONFIGURATIONINPUT_SCHEMA, (), |_, member, deser| {
         115  +
        deserializer.read_struct(&GETBUCKETINVENTORYCONFIGURATIONINPUT_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.id = 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.id = builder.id.or(Some(String::new()));
         132  +
        builder
         133  +
            .build()
         134  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         135  +
    }
         136  +
}
         137  +
impl GetBucketInventoryConfigurationInput {
         138  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         139  +
    /// Header-bound members are read directly from headers, avoiding runtime
         140  +
    /// member iteration overhead. Body members are read via the deserializer.
         141  +
    pub fn deserialize_with_response(
         142  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         143  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         144  +
        _status: u16,
         145  +
        _body: &[u8],
         146  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         147  +
        #[allow(unused_variables, unused_mut)]
         148  +
        let mut builder = Self::builder();
         149  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         150  +
            builder.expected_bucket_owner = Some(val.to_string());
         151  +
        }
         152  +
        #[allow(
         153  +
            unused_variables,
         154  +
            unreachable_code,
         155  +
            clippy::single_match,
         156  +
            clippy::match_single_binding,
         157  +
            clippy::diverging_sub_expression
         158  +
        )]
         159  +
        deserializer.read_struct(&GETBUCKETINVENTORYCONFIGURATIONINPUT_SCHEMA, &mut |member, deser| {
         160  +
            match member.member_index() {
         161  +
                Some(0) => {
         162  +
                    builder.bucket = Some(deser.read_string(member)?);
         163  +
                }
         164  +
                Some(1) => {
         165  +
                    builder.id = Some(deser.read_string(member)?);
         166  +
                }
         167  +
                Some(2) => { /* read from headers above */ }
         168  +
                _ => {}
         169  +
            }
         170  +
            Ok(())
         171  +
        })?;
  125    172   
        builder
  126    173   
            .build()
  127    174   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  128    175   
    }
  129    176   
}
  130    177   
impl GetBucketInventoryConfigurationInput {
  131    178   
    /// Creates a new builder-style object to manufacture [`GetBucketInventoryConfigurationInput`](crate::operation::get_bucket_inventory_configuration::GetBucketInventoryConfigurationInput).
  132    179   
    pub fn builder() -> crate::operation::get_bucket_inventory_configuration::builders::GetBucketInventoryConfigurationInputBuilder {
  133    180   
        crate::operation::get_bucket_inventory_configuration::builders::GetBucketInventoryConfigurationInputBuilder::default()
  134    181   
    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_inventory_configuration/_get_bucket_inventory_configuration_output.rs

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