AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c

Files changed:

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_cors/_put_bucket_cors_input.rs

@@ -25,25 +207,238 @@
   45     45   
    "com.amazonaws.s3.synthetic",
   46     46   
    "PutBucketCorsInput",
   47     47   
);
   48     48   
static PUTBUCKETCORSINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static(
   50     50   
        "com.amazonaws.s3.synthetic#PutBucketCorsInput$Bucket",
   51     51   
        "com.amazonaws.s3.synthetic",
   52     52   
        "PutBucketCorsInput",
   53     53   
    ),
   54     54   
    ::aws_smithy_schema::ShapeType::String,
   55         -
    "bucket",
          55  +
    "Bucket",
   56     56   
    0,
   57     57   
)
   58     58   
.with_http_label();
   59     59   
static PUTBUCKETCORSINPUT_MEMBER_CORS_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.s3.synthetic#PutBucketCorsInput$CORSConfiguration",
   62     62   
        "com.amazonaws.s3.synthetic",
   63     63   
        "PutBucketCorsInput",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66         -
    "cors_configuration",
          66  +
    "CORSConfiguration",
   67     67   
    1,
   68     68   
)
   69     69   
.with_xml_name("CORSConfiguration")
   70     70   
.with_http_payload();
   71     71   
static PUTBUCKETCORSINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.s3.synthetic#PutBucketCorsInput$ContentMD5",
   74     74   
        "com.amazonaws.s3.synthetic",
   75     75   
        "PutBucketCorsInput",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::String,
   78         -
    "content_md5",
          78  +
    "ContentMD5",
   79     79   
    2,
   80     80   
)
   81     81   
.with_http_header("Content-MD5");
   82     82   
static PUTBUCKETCORSINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.s3.synthetic#PutBucketCorsInput$ChecksumAlgorithm",
   85     85   
        "com.amazonaws.s3.synthetic",
   86     86   
        "PutBucketCorsInput",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "checksum_algorithm",
          89  +
    "ChecksumAlgorithm",
   90     90   
    3,
   91     91   
)
   92     92   
.with_http_header("x-amz-sdk-checksum-algorithm");
   93     93   
static PUTBUCKETCORSINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.s3.synthetic#PutBucketCorsInput$ExpectedBucketOwner",
   96     96   
        "com.amazonaws.s3.synthetic",
   97     97   
        "PutBucketCorsInput",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "expected_bucket_owner",
         100  +
    "ExpectedBucketOwner",
  101    101   
    4,
  102    102   
)
  103    103   
.with_http_header("x-amz-expected-bucket-owner");
  104    104   
static PUTBUCKETCORSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  105    105   
    PUTBUCKETCORSINPUT_SCHEMA_ID,
  106    106   
    ::aws_smithy_schema::ShapeType::Structure,
  107    107   
    &[
  108    108   
        &PUTBUCKETCORSINPUT_MEMBER_BUCKET,
  109    109   
        &PUTBUCKETCORSINPUT_MEMBER_CORS_CONFIGURATION,
  110    110   
        &PUTBUCKETCORSINPUT_MEMBER_CONTENT_MD5,
  111    111   
        &PUTBUCKETCORSINPUT_MEMBER_CHECKSUM_ALGORITHM,
  112    112   
        &PUTBUCKETCORSINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
  113    113   
    ],
  114         -
);
         114  +
)
         115  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?cors", None));
  115    116   
impl PutBucketCorsInput {
  116    117   
    /// The schema for this shape.
  117    118   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETCORSINPUT_SCHEMA;
  118    119   
}
  119    120   
impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketCorsInput {
  120    121   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  121    122   
    fn serialize_members(
  122    123   
        &self,
  123    124   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  124    125   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  125    126   
        if let Some(ref val) = self.bucket {
  126    127   
            ser.write_string(&PUTBUCKETCORSINPUT_MEMBER_BUCKET, val)?;
  127    128   
        }
  128    129   
        if let Some(ref val) = self.cors_configuration {
  129    130   
            ser.write_struct(&PUTBUCKETCORSINPUT_MEMBER_CORS_CONFIGURATION, val)?;
  130    131   
        }
  131    132   
        if let Some(ref val) = self.content_md5 {
  132    133   
            ser.write_string(&PUTBUCKETCORSINPUT_MEMBER_CONTENT_MD5, val)?;
  133    134   
        }
  134    135   
        if let Some(ref val) = self.checksum_algorithm {
  135    136   
            ser.write_string(&PUTBUCKETCORSINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
  136    137   
        }
  137    138   
        if let Some(ref val) = self.expected_bucket_owner {
  138    139   
            ser.write_string(&PUTBUCKETCORSINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
  139    140   
        }
  140    141   
        Ok(())
  141    142   
    }
  142    143   
}
  143    144   
impl PutBucketCorsInput {
  144    145   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  145         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  146         -
        deserializer: &mut D,
         146  +
    pub fn deserialize(
         147  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  147    148   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  148    149   
        #[allow(unused_variables, unused_mut)]
  149    150   
        let mut builder = Self::builder();
  150    151   
        #[allow(
  151    152   
            unused_variables,
  152    153   
            unreachable_code,
  153    154   
            clippy::single_match,
  154    155   
            clippy::match_single_binding,
  155    156   
            clippy::diverging_sub_expression
  156    157   
        )]
  157         -
        deserializer.read_struct(&PUTBUCKETCORSINPUT_SCHEMA, (), |_, member, deser| {
         158  +
        deserializer.read_struct(&PUTBUCKETCORSINPUT_SCHEMA, &mut |member, deser| {
  158    159   
            match member.member_index() {
  159    160   
                Some(0) => {
  160    161   
                    builder.bucket = Some(deser.read_string(member)?);
  161    162   
                }
  162    163   
                Some(1) => {
  163    164   
                    builder.cors_configuration = Some(crate::types::CorsConfiguration::deserialize(deser)?);
  164    165   
                }
  165    166   
                Some(2) => {
  166    167   
                    builder.content_md5 = Some(deser.read_string(member)?);
  167    168   
                }
  168    169   
                Some(3) => {
  169    170   
                    builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
  170    171   
                }
  171    172   
                Some(4) => {
  172    173   
                    builder.expected_bucket_owner = Some(deser.read_string(member)?);
  173    174   
                }
  174    175   
                _ => {}
  175    176   
            }
  176    177   
            Ok(())
  177    178   
        })?;
         179  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         180  +
        builder
         181  +
            .build()
         182  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         183  +
    }
         184  +
}
         185  +
impl PutBucketCorsInput {
         186  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         187  +
    /// Header-bound members are read directly from headers, avoiding runtime
         188  +
    /// member iteration overhead. Body members are read via the deserializer.
         189  +
    pub fn deserialize_with_response(
         190  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         191  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         192  +
        _status: u16,
         193  +
        body: &[u8],
         194  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         195  +
        #[allow(unused_variables, unused_mut)]
         196  +
        let mut builder = Self::builder();
         197  +
        if let Some(val) = headers.get("Content-MD5") {
         198  +
            builder.content_md5 = Some(val.to_string());
         199  +
        }
         200  +
        if let Some(val) = headers.get("x-amz-sdk-checksum-algorithm") {
         201  +
            builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
         202  +
        }
         203  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         204  +
            builder.expected_bucket_owner = Some(val.to_string());
         205  +
        }
         206  +
        if !body.is_empty() {
         207  +
            builder.cors_configuration = Some(crate::types::CorsConfiguration::deserialize(deserializer)?);
         208  +
        }
  178    209   
        builder
  179    210   
            .build()
  180    211   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  181    212   
    }
  182    213   
}
  183    214   
impl PutBucketCorsInput {
  184    215   
    /// Creates a new builder-style object to manufacture [`PutBucketCorsInput`](crate::operation::put_bucket_cors::PutBucketCorsInput).
  185    216   
    pub fn builder() -> crate::operation::put_bucket_cors::builders::PutBucketCorsInputBuilder {
  186    217   
        crate::operation::put_bucket_cors::builders::PutBucketCorsInputBuilder::default()
  187    218   
    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_cors/_put_bucket_cors_output.rs

@@ -1,1 +81,112 @@
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5      5   
pub struct PutBucketCorsOutput {
    6      6   
    _extended_request_id: Option<String>,
    7      7   
    _request_id: Option<String>,
    8      8   
}
    9      9   
static PUTBUCKETCORSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
   10     10   
    "com.amazonaws.s3.synthetic#PutBucketCorsOutput",
   11     11   
    "com.amazonaws.s3.synthetic",
   12     12   
    "PutBucketCorsOutput",
   13     13   
);
   14         -
static PUTBUCKETCORSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
   15         -
    ::aws_smithy_schema::Schema::new_struct(PUTBUCKETCORSOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
          14  +
static PUTBUCKETCORSOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          15  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          16  +
    ::aws_smithy_schema::ShapeType::String,
          17  +
    "request_id",
          18  +
    0,
          19  +
)
          20  +
.with_http_header("x-amzn-requestid");
          21  +
static PUTBUCKETCORSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
          22  +
    PUTBUCKETCORSOUTPUT_SCHEMA_ID,
          23  +
    ::aws_smithy_schema::ShapeType::Structure,
          24  +
    &[&PUTBUCKETCORSOUTPUT_MEMBER__REQUEST_ID],
          25  +
);
   16     26   
impl PutBucketCorsOutput {
   17     27   
    /// The schema for this shape.
   18     28   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETCORSOUTPUT_SCHEMA;
   19     29   
}
   20     30   
impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketCorsOutput {
   21     31   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   22     32   
    fn serialize_members(
   23     33   
        &self,
   24     34   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   25     35   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   26     36   
        Ok(())
   27     37   
    }
   28     38   
}
   29     39   
impl PutBucketCorsOutput {
   30     40   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   31         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   32         -
        deserializer: &mut D,
          41  +
    pub fn deserialize(
          42  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   33     43   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   34     44   
        #[allow(unused_variables, unused_mut)]
   35     45   
        let mut builder = Self::builder();
   36     46   
        #[allow(
   37     47   
            unused_variables,
   38     48   
            unreachable_code,
   39     49   
            clippy::single_match,
   40     50   
            clippy::match_single_binding,
   41     51   
            clippy::diverging_sub_expression
   42     52   
        )]
   43         -
        deserializer.read_struct(&PUTBUCKETCORSOUTPUT_SCHEMA, (), |_, member, deser| {
          53  +
        deserializer.read_struct(&PUTBUCKETCORSOUTPUT_SCHEMA, &mut |member, deser| {
   44     54   
            match member.member_index() {
          55  +
                Some(0) => {
          56  +
                    builder._request_id = Some(deser.read_string(member)?);
          57  +
                }
   45     58   
                _ => {}
   46     59   
            }
   47     60   
            Ok(())
   48     61   
        })?;
   49     62   
        Ok(builder.build())
   50     63   
    }
   51     64   
}
          65  +
impl PutBucketCorsOutput {
          66  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          67  +
    /// Header-bound members are read directly from headers, avoiding runtime
          68  +
    /// member iteration overhead. Body members are read via the deserializer.
          69  +
    pub fn deserialize_with_response(
          70  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          71  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          72  +
        _status: u16,
          73  +
        _body: &[u8],
          74  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          75  +
        #[allow(unused_variables, unused_mut)]
          76  +
        let mut builder = Self::builder();
          77  +
        if let Some(val) = headers.get("x-amzn-requestid") {
          78  +
            builder._request_id = Some(val.to_string());
          79  +
        }
          80  +
        Ok(builder.build())
          81  +
    }
          82  +
}
   52     83   
impl crate::s3_request_id::RequestIdExt for PutBucketCorsOutput {
   53     84   
    fn extended_request_id(&self) -> Option<&str> {
   54     85   
        self._extended_request_id.as_deref()
   55     86   
    }
   56     87   
}
   57     88   
impl ::aws_types::request_id::RequestId for PutBucketCorsOutput {
   58     89   
    fn request_id(&self) -> Option<&str> {
   59     90   
        self._request_id.as_deref()
   60     91   
    }
   61     92   
}

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

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `PutBucketEncryption`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct PutBucketEncryption;
    6      6   
impl PutBucketEncryption {
    7      7   
    /// Creates a new `PutBucketEncryption`
    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::put_bucket_encryption::PutBucketEncryptionInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::put_bucket_encryption::PutBucketEncryptionOutput::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::put_bucket_encryption::PutBucketEncryptionInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::put_bucket_encryption::PutBucketEncryptionOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::put_bucket_encryption::PutBucketEncryptionError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -176,180 +238,243 @@
  196    200   
                                            ::std::borrow::Cow::Owned(transient_errors)
  197    201   
                                            }).build());
  198    202   
  199    203   
        ::std::borrow::Cow::Owned(rcb)
  200    204   
    }
  201    205   
}
  202    206   
  203    207   
#[derive(Debug)]
  204    208   
struct PutBucketEncryptionResponseDeserializer;
  205    209   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketEncryptionResponseDeserializer {
  206         -
    fn deserialize_nonstreaming(
         210  +
    fn deserialize_nonstreaming_with_config(
  207    211   
        &self,
  208    212   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         213  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  209    214   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  210    215   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  211    216   
        let headers = response.headers();
  212    217   
        let body = response.body().bytes().expect("body loaded");
  213    218   
        #[allow(unused_mut)]
  214    219   
        let mut force_error = false;
  215    220   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  216    221   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  217    222   
            force_error = true;
  218    223   
        }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_encryption/_put_bucket_encryption_input.rs

@@ -39,39 +221,252 @@
   59     59   
    "com.amazonaws.s3.synthetic",
   60     60   
    "PutBucketEncryptionInput",
   61     61   
);
   62     62   
static PUTBUCKETENCRYPTIONINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.s3.synthetic#PutBucketEncryptionInput$Bucket",
   65     65   
        "com.amazonaws.s3.synthetic",
   66     66   
        "PutBucketEncryptionInput",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "bucket",
          69  +
    "Bucket",
   70     70   
    0,
   71     71   
)
   72     72   
.with_http_label();
   73     73   
static PUTBUCKETENCRYPTIONINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.s3.synthetic#PutBucketEncryptionInput$ContentMD5",
   76     76   
        "com.amazonaws.s3.synthetic",
   77     77   
        "PutBucketEncryptionInput",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "content_md5",
          80  +
    "ContentMD5",
   81     81   
    1,
   82     82   
)
   83     83   
.with_http_header("Content-MD5");
   84     84   
static PUTBUCKETENCRYPTIONINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "com.amazonaws.s3.synthetic#PutBucketEncryptionInput$ChecksumAlgorithm",
   87     87   
        "com.amazonaws.s3.synthetic",
   88     88   
        "PutBucketEncryptionInput",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::String,
   91         -
    "checksum_algorithm",
          91  +
    "ChecksumAlgorithm",
   92     92   
    2,
   93     93   
)
   94     94   
.with_http_header("x-amz-sdk-checksum-algorithm");
   95     95   
static PUTBUCKETENCRYPTIONINPUT_MEMBER_SERVER_SIDE_ENCRYPTION_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.s3.synthetic#PutBucketEncryptionInput$ServerSideEncryptionConfiguration",
   98     98   
        "com.amazonaws.s3.synthetic",
   99     99   
        "PutBucketEncryptionInput",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::Structure,
  102         -
    "server_side_encryption_configuration",
         102  +
    "ServerSideEncryptionConfiguration",
  103    103   
    3,
  104    104   
)
  105    105   
.with_xml_name("ServerSideEncryptionConfiguration")
  106    106   
.with_http_payload();
  107    107   
static PUTBUCKETENCRYPTIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.s3.synthetic#PutBucketEncryptionInput$ExpectedBucketOwner",
  110    110   
        "com.amazonaws.s3.synthetic",
  111    111   
        "PutBucketEncryptionInput",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::String,
  114         -
    "expected_bucket_owner",
         114  +
    "ExpectedBucketOwner",
  115    115   
    4,
  116    116   
)
  117    117   
.with_http_header("x-amz-expected-bucket-owner");
  118    118   
static PUTBUCKETENCRYPTIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  119    119   
    PUTBUCKETENCRYPTIONINPUT_SCHEMA_ID,
  120    120   
    ::aws_smithy_schema::ShapeType::Structure,
  121    121   
    &[
  122    122   
        &PUTBUCKETENCRYPTIONINPUT_MEMBER_BUCKET,
  123    123   
        &PUTBUCKETENCRYPTIONINPUT_MEMBER_CONTENT_MD5,
  124    124   
        &PUTBUCKETENCRYPTIONINPUT_MEMBER_CHECKSUM_ALGORITHM,
  125    125   
        &PUTBUCKETENCRYPTIONINPUT_MEMBER_SERVER_SIDE_ENCRYPTION_CONFIGURATION,
  126    126   
        &PUTBUCKETENCRYPTIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
  127    127   
    ],
  128         -
);
         128  +
)
         129  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?encryption", None));
  129    130   
impl PutBucketEncryptionInput {
  130    131   
    /// The schema for this shape.
  131    132   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETENCRYPTIONINPUT_SCHEMA;
  132    133   
}
  133    134   
impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketEncryptionInput {
  134    135   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  135    136   
    fn serialize_members(
  136    137   
        &self,
  137    138   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  138    139   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  139    140   
        if let Some(ref val) = self.bucket {
  140    141   
            ser.write_string(&PUTBUCKETENCRYPTIONINPUT_MEMBER_BUCKET, val)?;
  141    142   
        }
  142    143   
        if let Some(ref val) = self.content_md5 {
  143    144   
            ser.write_string(&PUTBUCKETENCRYPTIONINPUT_MEMBER_CONTENT_MD5, val)?;
  144    145   
        }
  145    146   
        if let Some(ref val) = self.checksum_algorithm {
  146    147   
            ser.write_string(&PUTBUCKETENCRYPTIONINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
  147    148   
        }
  148    149   
        if let Some(ref val) = self.server_side_encryption_configuration {
  149    150   
            ser.write_struct(&PUTBUCKETENCRYPTIONINPUT_MEMBER_SERVER_SIDE_ENCRYPTION_CONFIGURATION, val)?;
  150    151   
        }
  151    152   
        if let Some(ref val) = self.expected_bucket_owner {
  152    153   
            ser.write_string(&PUTBUCKETENCRYPTIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
  153    154   
        }
  154    155   
        Ok(())
  155    156   
    }
  156    157   
}
  157    158   
impl PutBucketEncryptionInput {
  158    159   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  159         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  160         -
        deserializer: &mut D,
         160  +
    pub fn deserialize(
         161  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  161    162   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  162    163   
        #[allow(unused_variables, unused_mut)]
  163    164   
        let mut builder = Self::builder();
  164    165   
        #[allow(
  165    166   
            unused_variables,
  166    167   
            unreachable_code,
  167    168   
            clippy::single_match,
  168    169   
            clippy::match_single_binding,
  169    170   
            clippy::diverging_sub_expression
  170    171   
        )]
  171         -
        deserializer.read_struct(&PUTBUCKETENCRYPTIONINPUT_SCHEMA, (), |_, member, deser| {
         172  +
        deserializer.read_struct(&PUTBUCKETENCRYPTIONINPUT_SCHEMA, &mut |member, deser| {
  172    173   
            match member.member_index() {
  173    174   
                Some(0) => {
  174    175   
                    builder.bucket = Some(deser.read_string(member)?);
  175    176   
                }
  176    177   
                Some(1) => {
  177    178   
                    builder.content_md5 = Some(deser.read_string(member)?);
  178    179   
                }
  179    180   
                Some(2) => {
  180    181   
                    builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
  181    182   
                }
  182    183   
                Some(3) => {
  183    184   
                    builder.server_side_encryption_configuration = Some(crate::types::ServerSideEncryptionConfiguration::deserialize(deser)?);
  184    185   
                }
  185    186   
                Some(4) => {
  186    187   
                    builder.expected_bucket_owner = Some(deser.read_string(member)?);
  187    188   
                }
  188    189   
                _ => {}
  189    190   
            }
  190    191   
            Ok(())
  191    192   
        })?;
         193  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         194  +
        builder
         195  +
            .build()
         196  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         197  +
    }
         198  +
}
         199  +
impl PutBucketEncryptionInput {
         200  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         201  +
    /// Header-bound members are read directly from headers, avoiding runtime
         202  +
    /// member iteration overhead. Body members are read via the deserializer.
         203  +
    pub fn deserialize_with_response(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         205  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         206  +
        _status: u16,
         207  +
        body: &[u8],
         208  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         209  +
        #[allow(unused_variables, unused_mut)]
         210  +
        let mut builder = Self::builder();
         211  +
        if let Some(val) = headers.get("Content-MD5") {
         212  +
            builder.content_md5 = Some(val.to_string());
         213  +
        }
         214  +
        if let Some(val) = headers.get("x-amz-sdk-checksum-algorithm") {
         215  +
            builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
         216  +
        }
         217  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         218  +
            builder.expected_bucket_owner = Some(val.to_string());
         219  +
        }
         220  +
        if !body.is_empty() {
         221  +
            builder.server_side_encryption_configuration = Some(crate::types::ServerSideEncryptionConfiguration::deserialize(deserializer)?);
         222  +
        }
  192    223   
        builder
  193    224   
            .build()
  194    225   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  195    226   
    }
  196    227   
}
  197    228   
impl PutBucketEncryptionInput {
  198    229   
    /// Creates a new builder-style object to manufacture [`PutBucketEncryptionInput`](crate::operation::put_bucket_encryption::PutBucketEncryptionInput).
  199    230   
    pub fn builder() -> crate::operation::put_bucket_encryption::builders::PutBucketEncryptionInputBuilder {
  200    231   
        crate::operation::put_bucket_encryption::builders::PutBucketEncryptionInputBuilder::default()
  201    232   
    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_encryption/_put_bucket_encryption_output.rs

@@ -1,1 +81,112 @@
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5      5   
pub struct PutBucketEncryptionOutput {
    6      6   
    _extended_request_id: Option<String>,
    7      7   
    _request_id: Option<String>,
    8      8   
}
    9      9   
static PUTBUCKETENCRYPTIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
   10     10   
    "com.amazonaws.s3.synthetic#PutBucketEncryptionOutput",
   11     11   
    "com.amazonaws.s3.synthetic",
   12     12   
    "PutBucketEncryptionOutput",
   13     13   
);
   14         -
static PUTBUCKETENCRYPTIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
   15         -
    ::aws_smithy_schema::Schema::new_struct(PUTBUCKETENCRYPTIONOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
          14  +
static PUTBUCKETENCRYPTIONOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          15  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          16  +
    ::aws_smithy_schema::ShapeType::String,
          17  +
    "request_id",
          18  +
    0,
          19  +
)
          20  +
.with_http_header("x-amzn-requestid");
          21  +
static PUTBUCKETENCRYPTIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
          22  +
    PUTBUCKETENCRYPTIONOUTPUT_SCHEMA_ID,
          23  +
    ::aws_smithy_schema::ShapeType::Structure,
          24  +
    &[&PUTBUCKETENCRYPTIONOUTPUT_MEMBER__REQUEST_ID],
          25  +
);
   16     26   
impl PutBucketEncryptionOutput {
   17     27   
    /// The schema for this shape.
   18     28   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETENCRYPTIONOUTPUT_SCHEMA;
   19     29   
}
   20     30   
impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketEncryptionOutput {
   21     31   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   22     32   
    fn serialize_members(
   23     33   
        &self,
   24     34   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   25     35   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   26     36   
        Ok(())
   27     37   
    }
   28     38   
}
   29     39   
impl PutBucketEncryptionOutput {
   30     40   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   31         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   32         -
        deserializer: &mut D,
          41  +
    pub fn deserialize(
          42  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   33     43   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   34     44   
        #[allow(unused_variables, unused_mut)]
   35     45   
        let mut builder = Self::builder();
   36     46   
        #[allow(
   37     47   
            unused_variables,
   38     48   
            unreachable_code,
   39     49   
            clippy::single_match,
   40     50   
            clippy::match_single_binding,
   41     51   
            clippy::diverging_sub_expression
   42     52   
        )]
   43         -
        deserializer.read_struct(&PUTBUCKETENCRYPTIONOUTPUT_SCHEMA, (), |_, member, deser| {
          53  +
        deserializer.read_struct(&PUTBUCKETENCRYPTIONOUTPUT_SCHEMA, &mut |member, deser| {
   44     54   
            match member.member_index() {
          55  +
                Some(0) => {
          56  +
                    builder._request_id = Some(deser.read_string(member)?);
          57  +
                }
   45     58   
                _ => {}
   46     59   
            }
   47     60   
            Ok(())
   48     61   
        })?;
   49     62   
        Ok(builder.build())
   50     63   
    }
   51     64   
}
          65  +
impl PutBucketEncryptionOutput {
          66  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          67  +
    /// Header-bound members are read directly from headers, avoiding runtime
          68  +
    /// member iteration overhead. Body members are read via the deserializer.
          69  +
    pub fn deserialize_with_response(
          70  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          71  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          72  +
        _status: u16,
          73  +
        _body: &[u8],
          74  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          75  +
        #[allow(unused_variables, unused_mut)]
          76  +
        let mut builder = Self::builder();
          77  +
        if let Some(val) = headers.get("x-amzn-requestid") {
          78  +
            builder._request_id = Some(val.to_string());
          79  +
        }
          80  +
        Ok(builder.build())
          81  +
    }
          82  +
}
   52     83   
impl crate::s3_request_id::RequestIdExt for PutBucketEncryptionOutput {
   53     84   
    fn extended_request_id(&self) -> Option<&str> {
   54     85   
        self._extended_request_id.as_deref()
   55     86   
    }
   56     87   
}
   57     88   
impl ::aws_types::request_id::RequestId for PutBucketEncryptionOutput {
   58     89   
    fn request_id(&self) -> Option<&str> {
   59     90   
        self._request_id.as_deref()
   60     91   
    }
   61     92   
}

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

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_intelligent_tiering_configuration/_put_bucket_intelligent_tiering_configuration_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_intelligent_tiering_configuration/_put_bucket_intelligent_tiering_configuration_output.rs

@@ -1,1 +84,112 @@
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5      5   
pub struct PutBucketIntelligentTieringConfigurationOutput {
    6      6   
    _extended_request_id: Option<String>,
    7      7   
    _request_id: Option<String>,
    8      8   
}
    9      9   
static PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
   10     10   
    "com.amazonaws.s3.synthetic#PutBucketIntelligentTieringConfigurationOutput",
   11     11   
    "com.amazonaws.s3.synthetic",
   12     12   
    "PutBucketIntelligentTieringConfigurationOutput",
   13     13   
);
          14  +
static PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          15  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          16  +
    ::aws_smithy_schema::ShapeType::String,
          17  +
    "request_id",
          18  +
    0,
          19  +
)
          20  +
.with_http_header("x-amzn-requestid");
   14     21   
static PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   15     22   
    PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_SCHEMA_ID,
   16     23   
    ::aws_smithy_schema::ShapeType::Structure,
   17         -
    &[],
          24  +
    &[&PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_MEMBER__REQUEST_ID],
   18     25   
);
   19     26   
impl PutBucketIntelligentTieringConfigurationOutput {
   20     27   
    /// The schema for this shape.
   21     28   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_SCHEMA;
   22     29   
}
   23     30   
impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketIntelligentTieringConfigurationOutput {
   24     31   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   25     32   
    fn serialize_members(
   26     33   
        &self,
   27     34   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   28     35   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   29     36   
        Ok(())
   30     37   
    }
   31     38   
}
   32     39   
impl PutBucketIntelligentTieringConfigurationOutput {
   33     40   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   34         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   35         -
        deserializer: &mut D,
          41  +
    pub fn deserialize(
          42  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   36     43   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   37     44   
        #[allow(unused_variables, unused_mut)]
   38     45   
        let mut builder = Self::builder();
   39     46   
        #[allow(
   40     47   
            unused_variables,
   41     48   
            unreachable_code,
   42     49   
            clippy::single_match,
   43     50   
            clippy::match_single_binding,
   44     51   
            clippy::diverging_sub_expression
   45     52   
        )]
   46         -
        deserializer.read_struct(&PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_SCHEMA, (), |_, member, deser| {
          53  +
        deserializer.read_struct(&PUTBUCKETINTELLIGENTTIERINGCONFIGURATIONOUTPUT_SCHEMA, &mut |member, deser| {
   47     54   
            match member.member_index() {
          55  +
                Some(0) => {
          56  +
                    builder._request_id = Some(deser.read_string(member)?);
          57  +
                }
   48     58   
                _ => {}
   49     59   
            }
   50     60   
            Ok(())
   51     61   
        })?;
   52     62   
        Ok(builder.build())
   53     63   
    }
   54     64   
}
          65  +
impl PutBucketIntelligentTieringConfigurationOutput {
          66  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          67  +
    /// Header-bound members are read directly from headers, avoiding runtime
          68  +
    /// member iteration overhead. Body members are read via the deserializer.
          69  +
    pub fn deserialize_with_response(
          70  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          71  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          72  +
        _status: u16,
          73  +
        _body: &[u8],
          74  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          75  +
        #[allow(unused_variables, unused_mut)]
          76  +
        let mut builder = Self::builder();
          77  +
        if let Some(val) = headers.get("x-amzn-requestid") {
          78  +
            builder._request_id = Some(val.to_string());
          79  +
        }
          80  +
        Ok(builder.build())
          81  +
    }
          82  +
}
   55     83   
impl crate::s3_request_id::RequestIdExt for PutBucketIntelligentTieringConfigurationOutput {
   56     84   
    fn extended_request_id(&self) -> Option<&str> {
   57     85   
        self._extended_request_id.as_deref()
   58     86   
    }
   59     87   
}
   60     88   
impl ::aws_types::request_id::RequestId for PutBucketIntelligentTieringConfigurationOutput {
   61     89   
    fn request_id(&self) -> Option<&str> {
   62     90   
        self._request_id.as_deref()
   63     91   
    }
   64     92   
}

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

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_inventory_configuration/_put_bucket_inventory_configuration_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_inventory_configuration/_put_bucket_inventory_configuration_output.rs

@@ -1,1 +84,112 @@
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5      5   
pub struct PutBucketInventoryConfigurationOutput {
    6      6   
    _extended_request_id: Option<String>,
    7      7   
    _request_id: Option<String>,
    8      8   
}
    9      9   
static PUTBUCKETINVENTORYCONFIGURATIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
   10     10   
    "com.amazonaws.s3.synthetic#PutBucketInventoryConfigurationOutput",
   11     11   
    "com.amazonaws.s3.synthetic",
   12     12   
    "PutBucketInventoryConfigurationOutput",
   13     13   
);
          14  +
static PUTBUCKETINVENTORYCONFIGURATIONOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          15  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          16  +
    ::aws_smithy_schema::ShapeType::String,
          17  +
    "request_id",
          18  +
    0,
          19  +
)
          20  +
.with_http_header("x-amzn-requestid");
   14     21   
static PUTBUCKETINVENTORYCONFIGURATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   15     22   
    PUTBUCKETINVENTORYCONFIGURATIONOUTPUT_SCHEMA_ID,
   16     23   
    ::aws_smithy_schema::ShapeType::Structure,
   17         -
    &[],
          24  +
    &[&PUTBUCKETINVENTORYCONFIGURATIONOUTPUT_MEMBER__REQUEST_ID],
   18     25   
);
   19     26   
impl PutBucketInventoryConfigurationOutput {
   20     27   
    /// The schema for this shape.
   21     28   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETINVENTORYCONFIGURATIONOUTPUT_SCHEMA;
   22     29   
}
   23     30   
impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketInventoryConfigurationOutput {
   24     31   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   25     32   
    fn serialize_members(
   26     33   
        &self,
   27     34   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   28     35   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   29     36   
        Ok(())
   30     37   
    }
   31     38   
}
   32     39   
impl PutBucketInventoryConfigurationOutput {
   33     40   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   34         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   35         -
        deserializer: &mut D,
          41  +
    pub fn deserialize(
          42  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   36     43   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   37     44   
        #[allow(unused_variables, unused_mut)]
   38     45   
        let mut builder = Self::builder();
   39     46   
        #[allow(
   40     47   
            unused_variables,
   41     48   
            unreachable_code,
   42     49   
            clippy::single_match,
   43     50   
            clippy::match_single_binding,
   44     51   
            clippy::diverging_sub_expression
   45     52   
        )]
   46         -
        deserializer.read_struct(&PUTBUCKETINVENTORYCONFIGURATIONOUTPUT_SCHEMA, (), |_, member, deser| {
          53  +
        deserializer.read_struct(&PUTBUCKETINVENTORYCONFIGURATIONOUTPUT_SCHEMA, &mut |member, deser| {
   47     54   
            match member.member_index() {
          55  +
                Some(0) => {
          56  +
                    builder._request_id = Some(deser.read_string(member)?);
          57  +
                }
   48     58   
                _ => {}
   49     59   
            }
   50     60   
            Ok(())
   51     61   
        })?;
   52     62   
        Ok(builder.build())
   53     63   
    }
   54     64   
}
          65  +
impl PutBucketInventoryConfigurationOutput {
          66  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          67  +
    /// Header-bound members are read directly from headers, avoiding runtime
          68  +
    /// member iteration overhead. Body members are read via the deserializer.
          69  +
    pub fn deserialize_with_response(
          70  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          71  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          72  +
        _status: u16,
          73  +
        _body: &[u8],
          74  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          75  +
        #[allow(unused_variables, unused_mut)]
          76  +
        let mut builder = Self::builder();
          77  +
        if let Some(val) = headers.get("x-amzn-requestid") {
          78  +
            builder._request_id = Some(val.to_string());
          79  +
        }
          80  +
        Ok(builder.build())
          81  +
    }
          82  +
}
   55     83   
impl crate::s3_request_id::RequestIdExt for PutBucketInventoryConfigurationOutput {
   56     84   
    fn extended_request_id(&self) -> Option<&str> {
   57     85   
        self._extended_request_id.as_deref()
   58     86   
    }
   59     87   
}
   60     88   
impl ::aws_types::request_id::RequestId for PutBucketInventoryConfigurationOutput {
   61     89   
    fn request_id(&self) -> Option<&str> {
   62     90   
        self._request_id.as_deref()
   63     91   
    }
   64     92   
}

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

@@ -1,1 +40,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `PutBucketLifecycleConfiguration`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct PutBucketLifecycleConfiguration;
    6      6   
impl PutBucketLifecycleConfiguration {
    7      7   
    /// Creates a new `PutBucketLifecycleConfiguration`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -192,198 +254,261 @@
  212    218   
                .build(),
  213    219   
            );
  214    220   
  215    221   
        ::std::borrow::Cow::Owned(rcb)
  216    222   
    }
  217    223   
}
  218    224   
  219    225   
#[derive(Debug)]
  220    226   
struct PutBucketLifecycleConfigurationResponseDeserializer;
  221    227   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketLifecycleConfigurationResponseDeserializer {
  222         -
    fn deserialize_nonstreaming(
         228  +
    fn deserialize_nonstreaming_with_config(
  223    229   
        &self,
  224    230   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         231  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  225    232   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  226    233   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  227    234   
        let headers = response.headers();
  228    235   
        let body = response.body().bytes().expect("body loaded");
  229    236   
        #[allow(unused_mut)]
  230    237   
        let mut force_error = false;
  231    238   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  232    239   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  233    240   
            force_error = true;
  234    241   
        }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_lifecycle_configuration/_put_bucket_lifecycle_configuration_input.rs

@@ -45,45 +233,264 @@
   65     65   
    "com.amazonaws.s3.synthetic",
   66     66   
    "PutBucketLifecycleConfigurationInput",
   67     67   
);
   68     68   
static PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.s3.synthetic#PutBucketLifecycleConfigurationInput$Bucket",
   71     71   
        "com.amazonaws.s3.synthetic",
   72     72   
        "PutBucketLifecycleConfigurationInput",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "bucket",
          75  +
    "Bucket",
   76     76   
    0,
   77     77   
)
   78     78   
.with_http_label();
   79     79   
static PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.s3.synthetic#PutBucketLifecycleConfigurationInput$ChecksumAlgorithm",
   82     82   
        "com.amazonaws.s3.synthetic",
   83     83   
        "PutBucketLifecycleConfigurationInput",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86         -
    "checksum_algorithm",
          86  +
    "ChecksumAlgorithm",
   87     87   
    1,
   88     88   
)
   89     89   
.with_http_header("x-amz-sdk-checksum-algorithm");
   90     90   
static PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_LIFECYCLE_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.s3.synthetic#PutBucketLifecycleConfigurationInput$LifecycleConfiguration",
   93     93   
        "com.amazonaws.s3.synthetic",
   94     94   
        "PutBucketLifecycleConfigurationInput",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::Structure,
   97         -
    "lifecycle_configuration",
          97  +
    "LifecycleConfiguration",
   98     98   
    2,
   99     99   
)
  100    100   
.with_xml_name("LifecycleConfiguration")
  101    101   
.with_http_payload();
  102    102   
static PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static(
  104    104   
        "com.amazonaws.s3.synthetic#PutBucketLifecycleConfigurationInput$ExpectedBucketOwner",
  105    105   
        "com.amazonaws.s3.synthetic",
  106    106   
        "PutBucketLifecycleConfigurationInput",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "expected_bucket_owner",
         109  +
    "ExpectedBucketOwner",
  110    110   
    3,
  111    111   
)
  112    112   
.with_http_header("x-amz-expected-bucket-owner");
  113    113   
static PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_TRANSITION_DEFAULT_MINIMUM_OBJECT_SIZE: ::aws_smithy_schema::Schema =
  114    114   
    ::aws_smithy_schema::Schema::new_member(
  115    115   
        ::aws_smithy_schema::ShapeId::from_static(
  116    116   
            "com.amazonaws.s3.synthetic#PutBucketLifecycleConfigurationInput$TransitionDefaultMinimumObjectSize",
  117    117   
            "com.amazonaws.s3.synthetic",
  118    118   
            "PutBucketLifecycleConfigurationInput",
  119    119   
        ),
  120    120   
        ::aws_smithy_schema::ShapeType::String,
  121         -
        "transition_default_minimum_object_size",
         121  +
        "TransitionDefaultMinimumObjectSize",
  122    122   
        4,
  123    123   
    )
  124    124   
    .with_http_header("x-amz-transition-default-minimum-object-size");
  125    125   
static PUTBUCKETLIFECYCLECONFIGURATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  126    126   
    PUTBUCKETLIFECYCLECONFIGURATIONINPUT_SCHEMA_ID,
  127    127   
    ::aws_smithy_schema::ShapeType::Structure,
  128    128   
    &[
  129    129   
        &PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_BUCKET,
  130    130   
        &PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_CHECKSUM_ALGORITHM,
  131    131   
        &PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_LIFECYCLE_CONFIGURATION,
  132    132   
        &PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
  133    133   
        &PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_TRANSITION_DEFAULT_MINIMUM_OBJECT_SIZE,
  134    134   
    ],
  135         -
);
         135  +
)
         136  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?lifecycle", None));
  136    137   
impl PutBucketLifecycleConfigurationInput {
  137    138   
    /// The schema for this shape.
  138    139   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETLIFECYCLECONFIGURATIONINPUT_SCHEMA;
  139    140   
}
  140    141   
impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketLifecycleConfigurationInput {
  141    142   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  142    143   
    fn serialize_members(
  143    144   
        &self,
  144    145   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  145    146   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  146    147   
        if let Some(ref val) = self.bucket {
  147    148   
            ser.write_string(&PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_BUCKET, val)?;
  148    149   
        }
  149    150   
        if let Some(ref val) = self.checksum_algorithm {
  150    151   
            ser.write_string(&PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
  151    152   
        }
  152    153   
        if let Some(ref val) = self.lifecycle_configuration {
  153    154   
            ser.write_struct(&PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_LIFECYCLE_CONFIGURATION, val)?;
  154    155   
        }
  155    156   
        if let Some(ref val) = self.expected_bucket_owner {
  156    157   
            ser.write_string(&PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
  157    158   
        }
  158    159   
        if let Some(ref val) = self.transition_default_minimum_object_size {
  159    160   
            ser.write_string(
  160    161   
                &PUTBUCKETLIFECYCLECONFIGURATIONINPUT_MEMBER_TRANSITION_DEFAULT_MINIMUM_OBJECT_SIZE,
  161    162   
                val.as_str(),
  162    163   
            )?;
  163    164   
        }
  164    165   
        Ok(())
  165    166   
    }
  166    167   
}
  167    168   
impl PutBucketLifecycleConfigurationInput {
  168    169   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  169         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  170         -
        deserializer: &mut D,
         170  +
    pub fn deserialize(
         171  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  171    172   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  172    173   
        #[allow(unused_variables, unused_mut)]
  173    174   
        let mut builder = Self::builder();
  174    175   
        #[allow(
  175    176   
            unused_variables,
  176    177   
            unreachable_code,
  177    178   
            clippy::single_match,
  178    179   
            clippy::match_single_binding,
  179    180   
            clippy::diverging_sub_expression
  180    181   
        )]
  181         -
        deserializer.read_struct(&PUTBUCKETLIFECYCLECONFIGURATIONINPUT_SCHEMA, (), |_, member, deser| {
         182  +
        deserializer.read_struct(&PUTBUCKETLIFECYCLECONFIGURATIONINPUT_SCHEMA, &mut |member, deser| {
  182    183   
            match member.member_index() {
  183    184   
                Some(0) => {
  184    185   
                    builder.bucket = Some(deser.read_string(member)?);
  185    186   
                }
  186    187   
                Some(1) => {
  187    188   
                    builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
  188    189   
                }
  189    190   
                Some(2) => {
  190    191   
                    builder.lifecycle_configuration = Some(crate::types::BucketLifecycleConfiguration::deserialize(deser)?);
  191    192   
                }
  192    193   
                Some(3) => {
  193    194   
                    builder.expected_bucket_owner = Some(deser.read_string(member)?);
  194    195   
                }
  195    196   
                Some(4) => {
  196    197   
                    builder.transition_default_minimum_object_size = Some(crate::types::TransitionDefaultMinimumObjectSize::from(
  197    198   
                        deser.read_string(member)?.as_str(),
  198    199   
                    ));
  199    200   
                }
  200    201   
                _ => {}
  201    202   
            }
  202    203   
            Ok(())
  203    204   
        })?;
         205  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         206  +
        builder
         207  +
            .build()
         208  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         209  +
    }
         210  +
}
         211  +
impl PutBucketLifecycleConfigurationInput {
         212  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         213  +
    /// Header-bound members are read directly from headers, avoiding runtime
         214  +
    /// member iteration overhead. Body members are read via the deserializer.
         215  +
    pub fn deserialize_with_response(
         216  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         217  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         218  +
        _status: u16,
         219  +
        body: &[u8],
         220  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         221  +
        #[allow(unused_variables, unused_mut)]
         222  +
        let mut builder = Self::builder();
         223  +
        if let Some(val) = headers.get("x-amz-sdk-checksum-algorithm") {
         224  +
            builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
         225  +
        }
         226  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         227  +
            builder.expected_bucket_owner = Some(val.to_string());
         228  +
        }
         229  +
        if let Some(val) = headers.get("x-amz-transition-default-minimum-object-size") {
         230  +
            builder.transition_default_minimum_object_size = Some(crate::types::TransitionDefaultMinimumObjectSize::from(val));
         231  +
        }
         232  +
        if !body.is_empty() {
         233  +
            builder.lifecycle_configuration = Some(crate::types::BucketLifecycleConfiguration::deserialize(deserializer)?);
         234  +
        }
  204    235   
        builder
  205    236   
            .build()
  206    237   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  207    238   
    }
  208    239   
}
  209    240   
impl PutBucketLifecycleConfigurationInput {
  210    241   
    /// Creates a new builder-style object to manufacture [`PutBucketLifecycleConfigurationInput`](crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationInput).
  211    242   
    pub fn builder() -> crate::operation::put_bucket_lifecycle_configuration::builders::PutBucketLifecycleConfigurationInputBuilder {
  212    243   
        crate::operation::put_bucket_lifecycle_configuration::builders::PutBucketLifecycleConfigurationInputBuilder::default()
  213    244   
    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_lifecycle_configuration/_put_bucket_lifecycle_configuration_output.rs

@@ -18,18 +133,167 @@
   38     38   
    "PutBucketLifecycleConfigurationOutput",
   39     39   
);
   40     40   
static PUTBUCKETLIFECYCLECONFIGURATIONOUTPUT_MEMBER_TRANSITION_DEFAULT_MINIMUM_OBJECT_SIZE: ::aws_smithy_schema::Schema =
   41     41   
    ::aws_smithy_schema::Schema::new_member(
   42     42   
        ::aws_smithy_schema::ShapeId::from_static(
   43     43   
            "com.amazonaws.s3.synthetic#PutBucketLifecycleConfigurationOutput$TransitionDefaultMinimumObjectSize",
   44     44   
            "com.amazonaws.s3.synthetic",
   45     45   
            "PutBucketLifecycleConfigurationOutput",
   46     46   
        ),
   47     47   
        ::aws_smithy_schema::ShapeType::String,
   48         -
        "transition_default_minimum_object_size",
          48  +
        "TransitionDefaultMinimumObjectSize",
   49     49   
        0,
   50     50   
    )
   51     51   
    .with_http_header("x-amz-transition-default-minimum-object-size");
          52  +
static PUTBUCKETLIFECYCLECONFIGURATIONOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          53  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          54  +
    ::aws_smithy_schema::ShapeType::String,
          55  +
    "request_id",
          56  +
    1,
          57  +
)
          58  +
.with_http_header("x-amzn-requestid");
   52     59   
static PUTBUCKETLIFECYCLECONFIGURATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   53     60   
    PUTBUCKETLIFECYCLECONFIGURATIONOUTPUT_SCHEMA_ID,
   54     61   
    ::aws_smithy_schema::ShapeType::Structure,
   55         -
    &[&PUTBUCKETLIFECYCLECONFIGURATIONOUTPUT_MEMBER_TRANSITION_DEFAULT_MINIMUM_OBJECT_SIZE],
          62  +
    &[
          63  +
        &PUTBUCKETLIFECYCLECONFIGURATIONOUTPUT_MEMBER_TRANSITION_DEFAULT_MINIMUM_OBJECT_SIZE,
          64  +
        &PUTBUCKETLIFECYCLECONFIGURATIONOUTPUT_MEMBER__REQUEST_ID,
          65  +
    ],
   56     66   
);
   57     67   
impl PutBucketLifecycleConfigurationOutput {
   58     68   
    /// The schema for this shape.
   59     69   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETLIFECYCLECONFIGURATIONOUTPUT_SCHEMA;
   60     70   
}
   61     71   
impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketLifecycleConfigurationOutput {
   62     72   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   63     73   
    fn serialize_members(
   64     74   
        &self,
   65     75   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   66     76   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   67     77   
        if let Some(ref val) = self.transition_default_minimum_object_size {
   68     78   
            ser.write_string(
   69     79   
                &PUTBUCKETLIFECYCLECONFIGURATIONOUTPUT_MEMBER_TRANSITION_DEFAULT_MINIMUM_OBJECT_SIZE,
   70     80   
                val.as_str(),
   71     81   
            )?;
   72     82   
        }
   73     83   
        Ok(())
   74     84   
    }
   75     85   
}
   76     86   
impl PutBucketLifecycleConfigurationOutput {
   77     87   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   78         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   79         -
        deserializer: &mut D,
          88  +
    pub fn deserialize(
          89  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   80     90   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   81     91   
        #[allow(unused_variables, unused_mut)]
   82     92   
        let mut builder = Self::builder();
   83     93   
        #[allow(
   84     94   
            unused_variables,
   85     95   
            unreachable_code,
   86     96   
            clippy::single_match,
   87     97   
            clippy::match_single_binding,
   88     98   
            clippy::diverging_sub_expression
   89     99   
        )]
   90         -
        deserializer.read_struct(&PUTBUCKETLIFECYCLECONFIGURATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         100  +
        deserializer.read_struct(&PUTBUCKETLIFECYCLECONFIGURATIONOUTPUT_SCHEMA, &mut |member, deser| {
   91    101   
            match member.member_index() {
   92    102   
                Some(0) => {
   93    103   
                    builder.transition_default_minimum_object_size = Some(crate::types::TransitionDefaultMinimumObjectSize::from(
   94    104   
                        deser.read_string(member)?.as_str(),
   95    105   
                    ));
   96    106   
                }
         107  +
                Some(1) => {
         108  +
                    builder._request_id = Some(deser.read_string(member)?);
         109  +
                }
   97    110   
                _ => {}
   98    111   
            }
   99    112   
            Ok(())
  100    113   
        })?;
  101    114   
        Ok(builder.build())
  102    115   
    }
  103    116   
}
         117  +
impl PutBucketLifecycleConfigurationOutput {
         118  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         119  +
    /// Header-bound members are read directly from headers, avoiding runtime
         120  +
    /// member iteration overhead. Body members are read via the deserializer.
         121  +
    pub fn deserialize_with_response(
         122  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         123  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         124  +
        _status: u16,
         125  +
        _body: &[u8],
         126  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         127  +
        #[allow(unused_variables, unused_mut)]
         128  +
        let mut builder = Self::builder();
         129  +
        if let Some(val) = headers.get("x-amz-transition-default-minimum-object-size") {
         130  +
            builder.transition_default_minimum_object_size = Some(crate::types::TransitionDefaultMinimumObjectSize::from(val));
         131  +
        }
         132  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         133  +
            builder._request_id = Some(val.to_string());
         134  +
        }
         135  +
        Ok(builder.build())
         136  +
    }
         137  +
}
  104    138   
impl crate::s3_request_id::RequestIdExt for PutBucketLifecycleConfigurationOutput {
  105    139   
    fn extended_request_id(&self) -> Option<&str> {
  106    140   
        self._extended_request_id.as_deref()
  107    141   
    }
  108    142   
}
  109    143   
impl ::aws_types::request_id::RequestId for PutBucketLifecycleConfigurationOutput {
  110    144   
    fn request_id(&self) -> Option<&str> {
  111    145   
        self._request_id.as_deref()
  112    146   
    }
  113    147   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_logging.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 `PutBucketLogging`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct PutBucketLogging;
    6      6   
impl PutBucketLogging {
    7      7   
    /// Creates a new `PutBucketLogging`
    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::put_bucket_logging::PutBucketLoggingInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::put_bucket_logging::PutBucketLoggingOutput::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::put_bucket_logging::PutBucketLoggingInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::put_bucket_logging::PutBucketLoggingOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::put_bucket_logging::PutBucketLoggingError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -180,184 +242,247 @@
  200    204   
                    .build(),
  201    205   
            );
  202    206   
  203    207   
        ::std::borrow::Cow::Owned(rcb)
  204    208   
    }
  205    209   
}
  206    210   
  207    211   
#[derive(Debug)]
  208    212   
struct PutBucketLoggingResponseDeserializer;
  209    213   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutBucketLoggingResponseDeserializer {
  210         -
    fn deserialize_nonstreaming(
         214  +
    fn deserialize_nonstreaming_with_config(
  211    215   
        &self,
  212    216   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         217  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  213    218   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  214    219   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  215    220   
        let headers = response.headers();
  216    221   
        let body = response.body().bytes().expect("body loaded");
  217    222   
        #[allow(unused_mut)]
  218    223   
        let mut force_error = false;
  219    224   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  220    225   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  221    226   
            force_error = true;
  222    227   
        }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_logging/_put_bucket_logging_input.rs

@@ -25,25 +207,238 @@
   45     45   
    "com.amazonaws.s3.synthetic",
   46     46   
    "PutBucketLoggingInput",
   47     47   
);
   48     48   
static PUTBUCKETLOGGINGINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static(
   50     50   
        "com.amazonaws.s3.synthetic#PutBucketLoggingInput$Bucket",
   51     51   
        "com.amazonaws.s3.synthetic",
   52     52   
        "PutBucketLoggingInput",
   53     53   
    ),
   54     54   
    ::aws_smithy_schema::ShapeType::String,
   55         -
    "bucket",
          55  +
    "Bucket",
   56     56   
    0,
   57     57   
)
   58     58   
.with_http_label();
   59     59   
static PUTBUCKETLOGGINGINPUT_MEMBER_BUCKET_LOGGING_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.s3.synthetic#PutBucketLoggingInput$BucketLoggingStatus",
   62     62   
        "com.amazonaws.s3.synthetic",
   63     63   
        "PutBucketLoggingInput",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66         -
    "bucket_logging_status",
          66  +
    "BucketLoggingStatus",
   67     67   
    1,
   68     68   
)
   69     69   
.with_xml_name("BucketLoggingStatus")
   70     70   
.with_http_payload();
   71     71   
static PUTBUCKETLOGGINGINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.s3.synthetic#PutBucketLoggingInput$ContentMD5",
   74     74   
        "com.amazonaws.s3.synthetic",
   75     75   
        "PutBucketLoggingInput",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::String,
   78         -
    "content_md5",
          78  +
    "ContentMD5",
   79     79   
    2,
   80     80   
)
   81     81   
.with_http_header("Content-MD5");
   82     82   
static PUTBUCKETLOGGINGINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.s3.synthetic#PutBucketLoggingInput$ChecksumAlgorithm",
   85     85   
        "com.amazonaws.s3.synthetic",
   86     86   
        "PutBucketLoggingInput",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "checksum_algorithm",
          89  +
    "ChecksumAlgorithm",
   90     90   
    3,
   91     91   
)
   92     92   
.with_http_header("x-amz-sdk-checksum-algorithm");
   93     93   
static PUTBUCKETLOGGINGINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.s3.synthetic#PutBucketLoggingInput$ExpectedBucketOwner",
   96     96   
        "com.amazonaws.s3.synthetic",
   97     97   
        "PutBucketLoggingInput",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "expected_bucket_owner",
         100  +
    "ExpectedBucketOwner",
  101    101   
    4,
  102    102   
)
  103    103   
.with_http_header("x-amz-expected-bucket-owner");
  104    104   
static PUTBUCKETLOGGINGINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  105    105   
    PUTBUCKETLOGGINGINPUT_SCHEMA_ID,
  106    106   
    ::aws_smithy_schema::ShapeType::Structure,
  107    107   
    &[
  108    108   
        &PUTBUCKETLOGGINGINPUT_MEMBER_BUCKET,
  109    109   
        &PUTBUCKETLOGGINGINPUT_MEMBER_BUCKET_LOGGING_STATUS,
  110    110   
        &PUTBUCKETLOGGINGINPUT_MEMBER_CONTENT_MD5,
  111    111   
        &PUTBUCKETLOGGINGINPUT_MEMBER_CHECKSUM_ALGORITHM,
  112    112   
        &PUTBUCKETLOGGINGINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
  113    113   
    ],
  114         -
);
         114  +
)
         115  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?logging", None));
  115    116   
impl PutBucketLoggingInput {
  116    117   
    /// The schema for this shape.
  117    118   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTBUCKETLOGGINGINPUT_SCHEMA;
  118    119   
}
  119    120   
impl ::aws_smithy_schema::serde::SerializableStruct for PutBucketLoggingInput {
  120    121   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  121    122   
    fn serialize_members(
  122    123   
        &self,
  123    124   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  124    125   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  125    126   
        if let Some(ref val) = self.bucket {
  126    127   
            ser.write_string(&PUTBUCKETLOGGINGINPUT_MEMBER_BUCKET, val)?;
  127    128   
        }
  128    129   
        if let Some(ref val) = self.bucket_logging_status {
  129    130   
            ser.write_struct(&PUTBUCKETLOGGINGINPUT_MEMBER_BUCKET_LOGGING_STATUS, val)?;
  130    131   
        }
  131    132   
        if let Some(ref val) = self.content_md5 {
  132    133   
            ser.write_string(&PUTBUCKETLOGGINGINPUT_MEMBER_CONTENT_MD5, val)?;
  133    134   
        }
  134    135   
        if let Some(ref val) = self.checksum_algorithm {
  135    136   
            ser.write_string(&PUTBUCKETLOGGINGINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
  136    137   
        }
  137    138   
        if let Some(ref val) = self.expected_bucket_owner {
  138    139   
            ser.write_string(&PUTBUCKETLOGGINGINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
  139    140   
        }
  140    141   
        Ok(())
  141    142   
    }
  142    143   
}
  143    144   
impl PutBucketLoggingInput {
  144    145   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  145         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  146         -
        deserializer: &mut D,
         146  +
    pub fn deserialize(
         147  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  147    148   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  148    149   
        #[allow(unused_variables, unused_mut)]
  149    150   
        let mut builder = Self::builder();
  150    151   
        #[allow(
  151    152   
            unused_variables,
  152    153   
            unreachable_code,
  153    154   
            clippy::single_match,
  154    155   
            clippy::match_single_binding,
  155    156   
            clippy::diverging_sub_expression
  156    157   
        )]
  157         -
        deserializer.read_struct(&PUTBUCKETLOGGINGINPUT_SCHEMA, (), |_, member, deser| {
         158  +
        deserializer.read_struct(&PUTBUCKETLOGGINGINPUT_SCHEMA, &mut |member, deser| {
  158    159   
            match member.member_index() {
  159    160   
                Some(0) => {
  160    161   
                    builder.bucket = Some(deser.read_string(member)?);
  161    162   
                }
  162    163   
                Some(1) => {
  163    164   
                    builder.bucket_logging_status = Some(crate::types::BucketLoggingStatus::deserialize(deser)?);
  164    165   
                }
  165    166   
                Some(2) => {
  166    167   
                    builder.content_md5 = Some(deser.read_string(member)?);
  167    168   
                }
  168    169   
                Some(3) => {
  169    170   
                    builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
  170    171   
                }
  171    172   
                Some(4) => {
  172    173   
                    builder.expected_bucket_owner = Some(deser.read_string(member)?);
  173    174   
                }
  174    175   
                _ => {}
  175    176   
            }
  176    177   
            Ok(())
  177    178   
        })?;
         179  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         180  +
        builder
         181  +
            .build()
         182  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         183  +
    }
         184  +
}
         185  +
impl PutBucketLoggingInput {
         186  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         187  +
    /// Header-bound members are read directly from headers, avoiding runtime
         188  +
    /// member iteration overhead. Body members are read via the deserializer.
         189  +
    pub fn deserialize_with_response(
         190  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         191  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         192  +
        _status: u16,
         193  +
        body: &[u8],
         194  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         195  +
        #[allow(unused_variables, unused_mut)]
         196  +
        let mut builder = Self::builder();
         197  +
        if let Some(val) = headers.get("Content-MD5") {
         198  +
            builder.content_md5 = Some(val.to_string());
         199  +
        }
         200  +
        if let Some(val) = headers.get("x-amz-sdk-checksum-algorithm") {
         201  +
            builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
         202  +
        }
         203  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         204  +
            builder.expected_bucket_owner = Some(val.to_string());
         205  +
        }
         206  +
        if !body.is_empty() {
         207  +
            builder.bucket_logging_status = Some(crate::types::BucketLoggingStatus::deserialize(deserializer)?);
         208  +
        }
  178    209   
        builder
  179    210   
            .build()
  180    211   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  181    212   
    }
  182    213   
}
  183    214   
impl PutBucketLoggingInput {
  184    215   
    /// Creates a new builder-style object to manufacture [`PutBucketLoggingInput`](crate::operation::put_bucket_logging::PutBucketLoggingInput).
  185    216   
    pub fn builder() -> crate::operation::put_bucket_logging::builders::PutBucketLoggingInputBuilder {
  186    217   
        crate::operation::put_bucket_logging::builders::PutBucketLoggingInputBuilder::default()
  187    218   
    }