AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36

Files changed:

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_policy/_get_bucket_policy_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_policy/_get_bucket_policy_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_policy_status/_get_bucket_policy_status_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_policy_status/_get_bucket_policy_status_output.rs

@@ -1,1 +109,143 @@
   19     19   
    "com.amazonaws.s3.synthetic",
   20     20   
    "GetBucketPolicyStatusOutput",
   21     21   
);
   22     22   
static GETBUCKETPOLICYSTATUSOUTPUT_MEMBER_POLICY_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.s3.synthetic#GetBucketPolicyStatusOutput$PolicyStatus",
   25     25   
        "com.amazonaws.s3.synthetic",
   26     26   
        "GetBucketPolicyStatusOutput",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29         -
    "policy_status",
          29  +
    "PolicyStatus",
   30     30   
    0,
   31     31   
)
   32     32   
.with_http_payload();
          33  +
static GETBUCKETPOLICYSTATUSOUTPUT_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 GETBUCKETPOLICYSTATUSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     41   
    GETBUCKETPOLICYSTATUSOUTPUT_SCHEMA_ID,
   35     42   
    ::aws_smithy_schema::ShapeType::Structure,
   36         -
    &[&GETBUCKETPOLICYSTATUSOUTPUT_MEMBER_POLICY_STATUS],
          43  +
    &[
          44  +
        &GETBUCKETPOLICYSTATUSOUTPUT_MEMBER_POLICY_STATUS,
          45  +
        &GETBUCKETPOLICYSTATUSOUTPUT_MEMBER__REQUEST_ID,
          46  +
    ],
   37     47   
);
   38     48   
impl GetBucketPolicyStatusOutput {
   39     49   
    /// The schema for this shape.
   40     50   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETBUCKETPOLICYSTATUSOUTPUT_SCHEMA;
   41     51   
}
   42     52   
impl ::aws_smithy_schema::serde::SerializableStruct for GetBucketPolicyStatusOutput {
   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.policy_status {
   49     59   
            ser.write_struct(&GETBUCKETPOLICYSTATUSOUTPUT_MEMBER_POLICY_STATUS, val)?;
   50     60   
        }
   51     61   
        Ok(())
   52     62   
    }
   53     63   
}
   54     64   
impl GetBucketPolicyStatusOutput {
   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(&GETBUCKETPOLICYSTATUSOUTPUT_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&GETBUCKETPOLICYSTATUSOUTPUT_SCHEMA, &mut |member, deser| {
   69     79   
            match member.member_index() {
   70     80   
                Some(0) => {
   71     81   
                    builder.policy_status = Some(crate::types::PolicyStatus::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 GetBucketPolicyStatusOutput {
          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.policy_status = Some(crate::types::PolicyStatus::deserialize(deserializer)?);
         110  +
        }
         111  +
        Ok(builder.build())
         112  +
    }
         113  +
}
   80    114   
impl crate::s3_request_id::RequestIdExt for GetBucketPolicyStatusOutput {
   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 GetBucketPolicyStatusOutput {
   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_replication.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 `GetBucketReplication`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetBucketReplication;
    6      6   
impl GetBucketReplication {
    7      7   
    /// Creates a new `GetBucketReplication`
    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_replication::GetBucketReplicationInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_bucket_replication::GetBucketReplicationOutput::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_replication::GetBucketReplicationInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_bucket_replication::GetBucketReplicationOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_bucket_replication::GetBucketReplicationError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -119,123 +178,183 @@
  139    143   
        ::std::borrow::Cow::Owned(rcb)
  140    144   
    }
  141    145   
}
  142    146   
  143    147   
#[derive(Debug)]
  144    148   
struct GetBucketReplicationResponseDeserializer;
  145    149   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketReplicationResponseDeserializer {
  146    150   
    fn deserialize_nonstreaming(
  147    151   
        &self,
  148    152   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         153  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  149    154   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  150    155   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  151    156   
        let headers = response.headers();
  152    157   
        let body = response.body().bytes().expect("body loaded");
  153    158   
        #[allow(unused_mut)]
  154    159   
        let mut force_error = false;
  155    160   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  156    161   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  157    162   
            force_error = true;
  158    163   
        }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_replication/_get_bucket_replication_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_replication/_get_bucket_replication_output.rs

@@ -1,1 +109,143 @@
   19     19   
    "com.amazonaws.s3.synthetic",
   20     20   
    "GetBucketReplicationOutput",
   21     21   
);
   22     22   
static GETBUCKETREPLICATIONOUTPUT_MEMBER_REPLICATION_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#GetBucketReplicationOutput$ReplicationConfiguration",
   25     25   
        "com.amazonaws.s3.synthetic",
   26     26   
        "GetBucketReplicationOutput",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29         -
    "replication_configuration",
          29  +
    "ReplicationConfiguration",
   30     30   
    0,
   31     31   
)
   32     32   
.with_http_payload();
          33  +
static GETBUCKETREPLICATIONOUTPUT_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 GETBUCKETREPLICATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     41   
    GETBUCKETREPLICATIONOUTPUT_SCHEMA_ID,
   35     42   
    ::aws_smithy_schema::ShapeType::Structure,
   36         -
    &[&GETBUCKETREPLICATIONOUTPUT_MEMBER_REPLICATION_CONFIGURATION],
          43  +
    &[
          44  +
        &GETBUCKETREPLICATIONOUTPUT_MEMBER_REPLICATION_CONFIGURATION,
          45  +
        &GETBUCKETREPLICATIONOUTPUT_MEMBER__REQUEST_ID,
          46  +
    ],
   37     47   
);
   38     48   
impl GetBucketReplicationOutput {
   39     49   
    /// The schema for this shape.
   40     50   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETBUCKETREPLICATIONOUTPUT_SCHEMA;
   41     51   
}
   42     52   
impl ::aws_smithy_schema::serde::SerializableStruct for GetBucketReplicationOutput {
   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.replication_configuration {
   49     59   
            ser.write_struct(&GETBUCKETREPLICATIONOUTPUT_MEMBER_REPLICATION_CONFIGURATION, val)?;
   50     60   
        }
   51     61   
        Ok(())
   52     62   
    }
   53     63   
}
   54     64   
impl GetBucketReplicationOutput {
   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(&GETBUCKETREPLICATIONOUTPUT_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&GETBUCKETREPLICATIONOUTPUT_SCHEMA, &mut |member, deser| {
   69     79   
            match member.member_index() {
   70     80   
                Some(0) => {
   71     81   
                    builder.replication_configuration = Some(crate::types::ReplicationConfiguration::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 GetBucketReplicationOutput {
          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.replication_configuration = Some(crate::types::ReplicationConfiguration::deserialize(deserializer)?);
         110  +
        }
         111  +
        Ok(builder.build())
         112  +
    }
         113  +
}
   80    114   
impl crate::s3_request_id::RequestIdExt for GetBucketReplicationOutput {
   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 GetBucketReplicationOutput {
   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_request_payment.rs

@@ -1,1 +40,45 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GetBucketRequestPayment`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetBucketRequestPayment;
    6      6   
impl GetBucketRequestPayment {
    7      7   
    /// Creates a new `GetBucketRequestPayment`
    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_request_payment::GetBucketRequestPaymentInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          15  +
        crate::operation::get_bucket_request_payment::GetBucketRequestPaymentOutput::SCHEMA;
   11     16   
    pub(crate) async fn orchestrate(
   12     17   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     18   
        input: crate::operation::get_bucket_request_payment::GetBucketRequestPaymentInput,
   14     19   
    ) -> ::std::result::Result<
   15     20   
        crate::operation::get_bucket_request_payment::GetBucketRequestPaymentOutput,
   16     21   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     22   
            crate::operation::get_bucket_request_payment::GetBucketRequestPaymentError,
   18     23   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     24   
        >,
   20     25   
    > {
@@ -129,134 +188,194 @@
  149    154   
        ::std::borrow::Cow::Owned(rcb)
  150    155   
    }
  151    156   
}
  152    157   
  153    158   
#[derive(Debug)]
  154    159   
struct GetBucketRequestPaymentResponseDeserializer;
  155    160   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketRequestPaymentResponseDeserializer {
  156    161   
    fn deserialize_nonstreaming(
  157    162   
        &self,
  158    163   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         164  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  159    165   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  160    166   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  161    167   
        let headers = response.headers();
  162    168   
        let body = response.body().bytes().expect("body loaded");
  163    169   
        #[allow(unused_mut)]
  164    170   
        let mut force_error = false;
  165    171   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  166    172   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  167    173   
            force_error = true;
  168    174   
        }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_request_payment/_get_bucket_request_payment_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_request_payment/_get_bucket_request_payment_output.rs

@@ -1,1 +98,145 @@
   19     19   
    "com.amazonaws.s3.synthetic",
   20     20   
    "GetBucketRequestPaymentOutput",
   21     21   
);
   22     22   
static GETBUCKETREQUESTPAYMENTOUTPUT_MEMBER_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.s3.synthetic#GetBucketRequestPaymentOutput$Payer",
   25     25   
        "com.amazonaws.s3.synthetic",
   26     26   
        "GetBucketRequestPaymentOutput",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "payer",
          29  +
    "Payer",
   30     30   
    0,
   31     31   
);
          32  +
static GETBUCKETREQUESTPAYMENTOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          33  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          34  +
    ::aws_smithy_schema::ShapeType::String,
          35  +
    "request_id",
          36  +
    1,
          37  +
)
          38  +
.with_http_header("x-amzn-requestid");
   32     39   
static GETBUCKETREQUESTPAYMENTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     40   
    GETBUCKETREQUESTPAYMENTOUTPUT_SCHEMA_ID,
   34     41   
    ::aws_smithy_schema::ShapeType::Structure,
   35         -
    &[&GETBUCKETREQUESTPAYMENTOUTPUT_MEMBER_PAYER],
          42  +
    &[
          43  +
        &GETBUCKETREQUESTPAYMENTOUTPUT_MEMBER_PAYER,
          44  +
        &GETBUCKETREQUESTPAYMENTOUTPUT_MEMBER__REQUEST_ID,
          45  +
    ],
   36     46   
)
   37     47   
.with_xml_name("RequestPaymentConfiguration");
   38     48   
impl GetBucketRequestPaymentOutput {
   39     49   
    /// The schema for this shape.
   40     50   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETBUCKETREQUESTPAYMENTOUTPUT_SCHEMA;
   41     51   
}
   42     52   
impl ::aws_smithy_schema::serde::SerializableStruct for GetBucketRequestPaymentOutput {
   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.payer {
   49     59   
            ser.write_string(&GETBUCKETREQUESTPAYMENTOUTPUT_MEMBER_PAYER, val.as_str())?;
   50     60   
        }
   51     61   
        Ok(())
   52     62   
    }
   53     63   
}
   54     64   
impl GetBucketRequestPaymentOutput {
   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,
          68  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          69  +
        #[allow(unused_variables, unused_mut)]
          70  +
        let mut builder = Self::builder();
          71  +
        #[allow(
          72  +
            unused_variables,
          73  +
            unreachable_code,
          74  +
            clippy::single_match,
          75  +
            clippy::match_single_binding,
          76  +
            clippy::diverging_sub_expression
          77  +
        )]
          78  +
        deserializer.read_struct(&GETBUCKETREQUESTPAYMENTOUTPUT_SCHEMA, &mut |member, deser| {
          79  +
            match member.member_index() {
          80  +
                Some(0) => {
          81  +
                    builder.payer = Some(crate::types::Payer::from(deser.read_string(member)?.as_str()));
          82  +
                }
          83  +
                Some(1) => {
          84  +
                    builder._request_id = Some(deser.read_string(member)?);
          85  +
                }
          86  +
                _ => {}
          87  +
            }
          88  +
            Ok(())
          89  +
        })?;
          90  +
        Ok(builder.build())
          91  +
    }
          92  +
}
          93  +
impl GetBucketRequestPaymentOutput {
          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],
   58    102   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   59    103   
        #[allow(unused_variables, unused_mut)]
   60    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  +
        }
   61    108   
        #[allow(
   62    109   
            unused_variables,
   63    110   
            unreachable_code,
   64    111   
            clippy::single_match,
   65    112   
            clippy::match_single_binding,
   66    113   
            clippy::diverging_sub_expression
   67    114   
        )]
   68         -
        deserializer.read_struct(&GETBUCKETREQUESTPAYMENTOUTPUT_SCHEMA, (), |_, member, deser| {
         115  +
        deserializer.read_struct(&GETBUCKETREQUESTPAYMENTOUTPUT_SCHEMA, &mut |member, deser| {
   69    116   
            match member.member_index() {
   70    117   
                Some(0) => {
   71    118   
                    builder.payer = Some(crate::types::Payer::from(deser.read_string(member)?.as_str()));
   72    119   
                }
   73    120   
                _ => {}
   74    121   
            }
   75    122   
            Ok(())
   76    123   
        })?;
   77    124   
        Ok(builder.build())
   78    125   
    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_tagging.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 `GetBucketTagging`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetBucketTagging;
    6      6   
impl GetBucketTagging {
    7      7   
    /// Creates a new `GetBucketTagging`
    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_tagging::GetBucketTaggingInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_bucket_tagging::GetBucketTaggingOutput::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_tagging::GetBucketTaggingInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_bucket_tagging::GetBucketTaggingOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_bucket_tagging::GetBucketTaggingError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -124,128 +183,188 @@
  144    148   
        ::std::borrow::Cow::Owned(rcb)
  145    149   
    }
  146    150   
}
  147    151   
  148    152   
#[derive(Debug)]
  149    153   
struct GetBucketTaggingResponseDeserializer;
  150    154   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketTaggingResponseDeserializer {
  151    155   
    fn deserialize_nonstreaming(
  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_tagging/_get_bucket_tagging_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_tagging/_get_bucket_tagging_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_versioning/_get_bucket_versioning_input.rs

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