AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36

Files changed:

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

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

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

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `PutObjectTagging`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct PutObjectTagging;
    6      6   
impl PutObjectTagging {
    7      7   
    /// Creates a new `PutObjectTagging`
    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_object_tagging::PutObjectTaggingInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::put_object_tagging::PutObjectTaggingOutput::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_object_tagging::PutObjectTaggingInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::put_object_tagging::PutObjectTaggingOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::put_object_tagging::PutObjectTaggingError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -183,187 +242,247 @@
  203    207   
        ::std::borrow::Cow::Owned(rcb)
  204    208   
    }
  205    209   
}
  206    210   
  207    211   
#[derive(Debug)]
  208    212   
struct PutObjectTaggingResponseDeserializer;
  209    213   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutObjectTaggingResponseDeserializer {
  210    214   
    fn deserialize_nonstreaming(
  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_object_tagging/_put_object_tagging_input.rs

@@ -47,47 +283,318 @@
   67     67   
    "com.amazonaws.s3.synthetic",
   68     68   
    "PutObjectTaggingInput",
   69     69   
);
   70     70   
static PUTOBJECTTAGGINGINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.s3.synthetic#PutObjectTaggingInput$Bucket",
   73     73   
        "com.amazonaws.s3.synthetic",
   74     74   
        "PutObjectTaggingInput",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "bucket",
          77  +
    "Bucket",
   78     78   
    0,
   79     79   
)
   80     80   
.with_http_label();
   81     81   
static PUTOBJECTTAGGINGINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.s3.synthetic#PutObjectTaggingInput$Key",
   84     84   
        "com.amazonaws.s3.synthetic",
   85     85   
        "PutObjectTaggingInput",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::String,
   88         -
    "key",
          88  +
    "Key",
   89     89   
    1,
   90     90   
)
   91     91   
.with_http_label();
   92     92   
static PUTOBJECTTAGGINGINPUT_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "com.amazonaws.s3.synthetic#PutObjectTaggingInput$VersionId",
   95     95   
        "com.amazonaws.s3.synthetic",
   96     96   
        "PutObjectTaggingInput",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "version_id",
          99  +
    "VersionId",
  100    100   
    2,
  101    101   
)
  102    102   
.with_http_query("versionId");
  103    103   
static PUTOBJECTTAGGINGINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.s3.synthetic#PutObjectTaggingInput$ContentMD5",
  106    106   
        "com.amazonaws.s3.synthetic",
  107    107   
        "PutObjectTaggingInput",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::String,
  110         -
    "content_md5",
         110  +
    "ContentMD5",
  111    111   
    3,
  112    112   
)
  113    113   
.with_http_header("Content-MD5");
  114    114   
static PUTOBJECTTAGGINGINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "com.amazonaws.s3.synthetic#PutObjectTaggingInput$ChecksumAlgorithm",
  117    117   
        "com.amazonaws.s3.synthetic",
  118    118   
        "PutObjectTaggingInput",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::String,
  121         -
    "checksum_algorithm",
         121  +
    "ChecksumAlgorithm",
  122    122   
    4,
  123    123   
)
  124    124   
.with_http_header("x-amz-sdk-checksum-algorithm");
  125    125   
static PUTOBJECTTAGGINGINPUT_MEMBER_TAGGING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "com.amazonaws.s3.synthetic#PutObjectTaggingInput$Tagging",
  128    128   
        "com.amazonaws.s3.synthetic",
  129    129   
        "PutObjectTaggingInput",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::Structure,
  132         -
    "tagging",
         132  +
    "Tagging",
  133    133   
    5,
  134    134   
)
  135    135   
.with_xml_name("Tagging")
  136    136   
.with_http_payload();
  137    137   
static PUTOBJECTTAGGINGINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static(
  139    139   
        "com.amazonaws.s3.synthetic#PutObjectTaggingInput$ExpectedBucketOwner",
  140    140   
        "com.amazonaws.s3.synthetic",
  141    141   
        "PutObjectTaggingInput",
  142    142   
    ),
  143    143   
    ::aws_smithy_schema::ShapeType::String,
  144         -
    "expected_bucket_owner",
         144  +
    "ExpectedBucketOwner",
  145    145   
    6,
  146    146   
)
  147    147   
.with_http_header("x-amz-expected-bucket-owner");
  148    148   
static PUTOBJECTTAGGINGINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  149    149   
    ::aws_smithy_schema::ShapeId::from_static(
  150    150   
        "com.amazonaws.s3.synthetic#PutObjectTaggingInput$RequestPayer",
  151    151   
        "com.amazonaws.s3.synthetic",
  152    152   
        "PutObjectTaggingInput",
  153    153   
    ),
  154    154   
    ::aws_smithy_schema::ShapeType::String,
  155         -
    "request_payer",
         155  +
    "RequestPayer",
  156    156   
    7,
  157    157   
)
  158    158   
.with_http_header("x-amz-request-payer");
  159    159   
static PUTOBJECTTAGGINGINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  160    160   
    PUTOBJECTTAGGINGINPUT_SCHEMA_ID,
  161    161   
    ::aws_smithy_schema::ShapeType::Structure,
  162    162   
    &[
  163    163   
        &PUTOBJECTTAGGINGINPUT_MEMBER_BUCKET,
  164    164   
        &PUTOBJECTTAGGINGINPUT_MEMBER_KEY,
  165    165   
        &PUTOBJECTTAGGINGINPUT_MEMBER_VERSION_ID,
  166    166   
        &PUTOBJECTTAGGINGINPUT_MEMBER_CONTENT_MD5,
  167    167   
        &PUTOBJECTTAGGINGINPUT_MEMBER_CHECKSUM_ALGORITHM,
  168    168   
        &PUTOBJECTTAGGINGINPUT_MEMBER_TAGGING,
  169    169   
        &PUTOBJECTTAGGINGINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
  170    170   
        &PUTOBJECTTAGGINGINPUT_MEMBER_REQUEST_PAYER,
  171    171   
    ],
  172         -
);
         172  +
)
         173  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/{Key+}?tagging", None));
  173    174   
impl PutObjectTaggingInput {
  174    175   
    /// The schema for this shape.
  175    176   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTOBJECTTAGGINGINPUT_SCHEMA;
  176    177   
}
  177    178   
impl ::aws_smithy_schema::serde::SerializableStruct for PutObjectTaggingInput {
  178    179   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  179    180   
    fn serialize_members(
  180    181   
        &self,
  181    182   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  182    183   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  183    184   
        if let Some(ref val) = self.bucket {
  184    185   
            ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_BUCKET, val)?;
  185    186   
        }
  186    187   
        if let Some(ref val) = self.key {
  187    188   
            ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_KEY, val)?;
  188    189   
        }
  189    190   
        if let Some(ref val) = self.version_id {
  190    191   
            ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_VERSION_ID, val)?;
  191    192   
        }
  192    193   
        if let Some(ref val) = self.content_md5 {
  193    194   
            ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_CONTENT_MD5, val)?;
  194    195   
        }
  195    196   
        if let Some(ref val) = self.checksum_algorithm {
  196    197   
            ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
  197    198   
        }
  198    199   
        if let Some(ref val) = self.tagging {
  199    200   
            ser.write_struct(&PUTOBJECTTAGGINGINPUT_MEMBER_TAGGING, val)?;
  200    201   
        }
  201    202   
        if let Some(ref val) = self.expected_bucket_owner {
  202    203   
            ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
  203    204   
        }
  204    205   
        if let Some(ref val) = self.request_payer {
  205    206   
            ser.write_string(&PUTOBJECTTAGGINGINPUT_MEMBER_REQUEST_PAYER, val.as_str())?;
  206    207   
        }
  207    208   
        Ok(())
  208    209   
    }
  209    210   
}
  210    211   
impl PutObjectTaggingInput {
  211    212   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  212         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  213         -
        deserializer: &mut D,
         213  +
    pub fn deserialize(
         214  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  214    215   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  215    216   
        #[allow(unused_variables, unused_mut)]
  216    217   
        let mut builder = Self::builder();
  217    218   
        #[allow(
  218    219   
            unused_variables,
  219    220   
            unreachable_code,
  220    221   
            clippy::single_match,
  221    222   
            clippy::match_single_binding,
  222    223   
            clippy::diverging_sub_expression
  223    224   
        )]
  224         -
        deserializer.read_struct(&PUTOBJECTTAGGINGINPUT_SCHEMA, (), |_, member, deser| {
         225  +
        deserializer.read_struct(&PUTOBJECTTAGGINGINPUT_SCHEMA, &mut |member, deser| {
  225    226   
            match member.member_index() {
  226    227   
                Some(0) => {
  227    228   
                    builder.bucket = Some(deser.read_string(member)?);
  228    229   
                }
  229    230   
                Some(1) => {
  230    231   
                    builder.key = Some(deser.read_string(member)?);
  231    232   
                }
  232    233   
                Some(2) => {
  233    234   
                    builder.version_id = Some(deser.read_string(member)?);
  234    235   
                }
  235    236   
                Some(3) => {
  236    237   
                    builder.content_md5 = Some(deser.read_string(member)?);
  237    238   
                }
  238    239   
                Some(4) => {
  239    240   
                    builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
  240    241   
                }
  241    242   
                Some(5) => {
  242    243   
                    builder.tagging = Some(crate::types::Tagging::deserialize(deser)?);
  243    244   
                }
  244    245   
                Some(6) => {
  245    246   
                    builder.expected_bucket_owner = Some(deser.read_string(member)?);
  246    247   
                }
  247    248   
                Some(7) => {
  248    249   
                    builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
  249    250   
                }
  250    251   
                _ => {}
  251    252   
            }
  252    253   
            Ok(())
  253    254   
        })?;
         255  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         256  +
        builder.key = builder.key.or(Some(String::new()));
         257  +
        builder
         258  +
            .build()
         259  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         260  +
    }
         261  +
}
         262  +
impl PutObjectTaggingInput {
         263  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         264  +
    /// Header-bound members are read directly from headers, avoiding runtime
         265  +
    /// member iteration overhead. Body members are read via the deserializer.
         266  +
    pub fn deserialize_with_response(
         267  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         268  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         269  +
        _status: u16,
         270  +
        body: &[u8],
         271  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         272  +
        #[allow(unused_variables, unused_mut)]
         273  +
        let mut builder = Self::builder();
         274  +
        if let Some(val) = headers.get("Content-MD5") {
         275  +
            builder.content_md5 = Some(val.to_string());
         276  +
        }
         277  +
        if let Some(val) = headers.get("x-amz-sdk-checksum-algorithm") {
         278  +
            builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
         279  +
        }
         280  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         281  +
            builder.expected_bucket_owner = Some(val.to_string());
         282  +
        }
         283  +
        if let Some(val) = headers.get("x-amz-request-payer") {
         284  +
            builder.request_payer = Some(crate::types::RequestPayer::from(val));
         285  +
        }
         286  +
        if !body.is_empty() {
         287  +
            builder.tagging = Some(crate::types::Tagging::deserialize(deserializer)?);
         288  +
        }
  254    289   
        builder
  255    290   
            .build()
  256    291   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  257    292   
    }
  258    293   
}
  259    294   
impl PutObjectTaggingInput {
  260    295   
    /// Creates a new builder-style object to manufacture [`PutObjectTaggingInput`](crate::operation::put_object_tagging::PutObjectTaggingInput).
  261    296   
    pub fn builder() -> crate::operation::put_object_tagging::builders::PutObjectTaggingInputBuilder {
  262    297   
        crate::operation::put_object_tagging::builders::PutObjectTaggingInputBuilder::default()
  263    298   
    }

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

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

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

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

@@ -25,25 +207,238 @@
   45     45   
    "com.amazonaws.s3.synthetic",
   46     46   
    "PutPublicAccessBlockInput",
   47     47   
);
   48     48   
static PUTPUBLICACCESSBLOCKINPUT_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#PutPublicAccessBlockInput$Bucket",
   51     51   
        "com.amazonaws.s3.synthetic",
   52     52   
        "PutPublicAccessBlockInput",
   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 PUTPUBLICACCESSBLOCKINPUT_MEMBER_CONTENT_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.s3.synthetic#PutPublicAccessBlockInput$ContentMD5",
   62     62   
        "com.amazonaws.s3.synthetic",
   63     63   
        "PutPublicAccessBlockInput",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "content_md5",
          66  +
    "ContentMD5",
   67     67   
    1,
   68     68   
)
   69     69   
.with_http_header("Content-MD5");
   70     70   
static PUTPUBLICACCESSBLOCKINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.s3.synthetic#PutPublicAccessBlockInput$ChecksumAlgorithm",
   73     73   
        "com.amazonaws.s3.synthetic",
   74     74   
        "PutPublicAccessBlockInput",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "checksum_algorithm",
          77  +
    "ChecksumAlgorithm",
   78     78   
    2,
   79     79   
)
   80     80   
.with_http_header("x-amz-sdk-checksum-algorithm");
   81     81   
static PUTPUBLICACCESSBLOCKINPUT_MEMBER_PUBLIC_ACCESS_BLOCK_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.s3.synthetic#PutPublicAccessBlockInput$PublicAccessBlockConfiguration",
   84     84   
        "com.amazonaws.s3.synthetic",
   85     85   
        "PutPublicAccessBlockInput",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::Structure,
   88         -
    "public_access_block_configuration",
          88  +
    "PublicAccessBlockConfiguration",
   89     89   
    3,
   90     90   
)
   91     91   
.with_xml_name("PublicAccessBlockConfiguration")
   92     92   
.with_http_payload();
   93     93   
static PUTPUBLICACCESSBLOCKINPUT_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#PutPublicAccessBlockInput$ExpectedBucketOwner",
   96     96   
        "com.amazonaws.s3.synthetic",
   97     97   
        "PutPublicAccessBlockInput",
   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 PUTPUBLICACCESSBLOCKINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  105    105   
    PUTPUBLICACCESSBLOCKINPUT_SCHEMA_ID,
  106    106   
    ::aws_smithy_schema::ShapeType::Structure,
  107    107   
    &[
  108    108   
        &PUTPUBLICACCESSBLOCKINPUT_MEMBER_BUCKET,
  109    109   
        &PUTPUBLICACCESSBLOCKINPUT_MEMBER_CONTENT_MD5,
  110    110   
        &PUTPUBLICACCESSBLOCKINPUT_MEMBER_CHECKSUM_ALGORITHM,
  111    111   
        &PUTPUBLICACCESSBLOCKINPUT_MEMBER_PUBLIC_ACCESS_BLOCK_CONFIGURATION,
  112    112   
        &PUTPUBLICACCESSBLOCKINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
  113    113   
    ],
  114         -
);
         114  +
)
         115  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/?publicAccessBlock", None));
  115    116   
impl PutPublicAccessBlockInput {
  116    117   
    /// The schema for this shape.
  117    118   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTPUBLICACCESSBLOCKINPUT_SCHEMA;
  118    119   
}
  119    120   
impl ::aws_smithy_schema::serde::SerializableStruct for PutPublicAccessBlockInput {
  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(&PUTPUBLICACCESSBLOCKINPUT_MEMBER_BUCKET, val)?;
  127    128   
        }
  128    129   
        if let Some(ref val) = self.content_md5 {
  129    130   
            ser.write_string(&PUTPUBLICACCESSBLOCKINPUT_MEMBER_CONTENT_MD5, val)?;
  130    131   
        }
  131    132   
        if let Some(ref val) = self.checksum_algorithm {
  132    133   
            ser.write_string(&PUTPUBLICACCESSBLOCKINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
  133    134   
        }
  134    135   
        if let Some(ref val) = self.public_access_block_configuration {
  135    136   
            ser.write_struct(&PUTPUBLICACCESSBLOCKINPUT_MEMBER_PUBLIC_ACCESS_BLOCK_CONFIGURATION, val)?;
  136    137   
        }
  137    138   
        if let Some(ref val) = self.expected_bucket_owner {
  138    139   
            ser.write_string(&PUTPUBLICACCESSBLOCKINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
  139    140   
        }
  140    141   
        Ok(())
  141    142   
    }
  142    143   
}
  143    144   
impl PutPublicAccessBlockInput {
  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(&PUTPUBLICACCESSBLOCKINPUT_SCHEMA, (), |_, member, deser| {
         158  +
        deserializer.read_struct(&PUTPUBLICACCESSBLOCKINPUT_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.content_md5 = Some(deser.read_string(member)?);
  164    165   
                }
  165    166   
                Some(2) => {
  166    167   
                    builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
  167    168   
                }
  168    169   
                Some(3) => {
  169    170   
                    builder.public_access_block_configuration = Some(crate::types::PublicAccessBlockConfiguration::deserialize(deser)?);
  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 PutPublicAccessBlockInput {
         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.public_access_block_configuration = Some(crate::types::PublicAccessBlockConfiguration::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 PutPublicAccessBlockInput {
  184    215   
    /// Creates a new builder-style object to manufacture [`PutPublicAccessBlockInput`](crate::operation::put_public_access_block::PutPublicAccessBlockInput).
  185    216   
    pub fn builder() -> crate::operation::put_public_access_block::builders::PutPublicAccessBlockInputBuilder {
  186    217   
        crate::operation::put_public_access_block::builders::PutPublicAccessBlockInputBuilder::default()
  187    218   
    }

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

@@ -1,1 +81,112 @@
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5      5   
pub struct PutPublicAccessBlockOutput {
    6      6   
    _extended_request_id: Option<String>,
    7      7   
    _request_id: Option<String>,
    8      8   
}
    9      9   
static PUTPUBLICACCESSBLOCKOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
   10     10   
    "com.amazonaws.s3.synthetic#PutPublicAccessBlockOutput",
   11     11   
    "com.amazonaws.s3.synthetic",
   12     12   
    "PutPublicAccessBlockOutput",
   13     13   
);
   14         -
static PUTPUBLICACCESSBLOCKOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
   15         -
    ::aws_smithy_schema::Schema::new_struct(PUTPUBLICACCESSBLOCKOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
          14  +
static PUTPUBLICACCESSBLOCKOUTPUT_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 PUTPUBLICACCESSBLOCKOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
          22  +
    PUTPUBLICACCESSBLOCKOUTPUT_SCHEMA_ID,
          23  +
    ::aws_smithy_schema::ShapeType::Structure,
          24  +
    &[&PUTPUBLICACCESSBLOCKOUTPUT_MEMBER__REQUEST_ID],
          25  +
);
   16     26   
impl PutPublicAccessBlockOutput {
   17     27   
    /// The schema for this shape.
   18     28   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTPUBLICACCESSBLOCKOUTPUT_SCHEMA;
   19     29   
}
   20     30   
impl ::aws_smithy_schema::serde::SerializableStruct for PutPublicAccessBlockOutput {
   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 PutPublicAccessBlockOutput {
   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(&PUTPUBLICACCESSBLOCKOUTPUT_SCHEMA, (), |_, member, deser| {
          53  +
        deserializer.read_struct(&PUTPUBLICACCESSBLOCKOUTPUT_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 PutPublicAccessBlockOutput {
          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 PutPublicAccessBlockOutput {
   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 PutPublicAccessBlockOutput {
   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/rename_object.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 `RenameObject`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct RenameObject;
    6      6   
impl RenameObject {
    7      7   
    /// Creates a new `RenameObject`
    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::rename_object::RenameObjectInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::rename_object::RenameObjectOutput::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::rename_object::RenameObjectInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::rename_object::RenameObjectOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::rename_object::RenameObjectError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -131,135 +190,195 @@
  151    155   
        ::std::borrow::Cow::Owned(rcb)
  152    156   
    }
  153    157   
}
  154    158   
  155    159   
#[derive(Debug)]
  156    160   
struct RenameObjectResponseDeserializer;
  157    161   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RenameObjectResponseDeserializer {
  158    162   
    fn deserialize_nonstreaming(
  159    163   
        &self,
  160    164   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         165  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  161    166   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  162    167   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  163    168   
        let headers = response.headers();
  164    169   
        let body = response.body().bytes().expect("body loaded");
  165    170   
        #[allow(unused_mut)]
  166    171   
        let mut force_error = false;
  167    172   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  168    173   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  169    174   
            force_error = true;
  170    175   
        }

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

@@ -73,73 +380,463 @@
   93     93   
    "com.amazonaws.s3.synthetic",
   94     94   
    "RenameObjectInput",
   95     95   
);
   96     96   
static RENAMEOBJECTINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static(
   98     98   
        "com.amazonaws.s3.synthetic#RenameObjectInput$Bucket",
   99     99   
        "com.amazonaws.s3.synthetic",
  100    100   
        "RenameObjectInput",
  101    101   
    ),
  102    102   
    ::aws_smithy_schema::ShapeType::String,
  103         -
    "bucket",
         103  +
    "Bucket",
  104    104   
    0,
  105    105   
)
  106    106   
.with_http_label();
  107    107   
static RENAMEOBJECTINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.s3.synthetic#RenameObjectInput$Key",
  110    110   
        "com.amazonaws.s3.synthetic",
  111    111   
        "RenameObjectInput",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::String,
  114         -
    "key",
         114  +
    "Key",
  115    115   
    1,
  116    116   
)
  117    117   
.with_http_label();
  118    118   
static RENAMEOBJECTINPUT_MEMBER_RENAME_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.s3.synthetic#RenameObjectInput$RenameSource",
  121    121   
        "com.amazonaws.s3.synthetic",
  122    122   
        "RenameObjectInput",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::String,
  125         -
    "rename_source",
         125  +
    "RenameSource",
  126    126   
    2,
  127    127   
)
  128    128   
.with_http_header("x-amz-rename-source");
  129    129   
static RENAMEOBJECTINPUT_MEMBER_DESTINATION_IF_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static(
  131    131   
        "com.amazonaws.s3.synthetic#RenameObjectInput$DestinationIfMatch",
  132    132   
        "com.amazonaws.s3.synthetic",
  133    133   
        "RenameObjectInput",
  134    134   
    ),
  135    135   
    ::aws_smithy_schema::ShapeType::String,
  136         -
    "destination_if_match",
         136  +
    "DestinationIfMatch",
  137    137   
    3,
  138    138   
)
  139    139   
.with_http_header("If-Match");
  140    140   
static RENAMEOBJECTINPUT_MEMBER_DESTINATION_IF_NONE_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static(
  142    142   
        "com.amazonaws.s3.synthetic#RenameObjectInput$DestinationIfNoneMatch",
  143    143   
        "com.amazonaws.s3.synthetic",
  144    144   
        "RenameObjectInput",
  145    145   
    ),
  146    146   
    ::aws_smithy_schema::ShapeType::String,
  147         -
    "destination_if_none_match",
         147  +
    "DestinationIfNoneMatch",
  148    148   
    4,
  149    149   
)
  150    150   
.with_http_header("If-None-Match");
  151    151   
static RENAMEOBJECTINPUT_MEMBER_DESTINATION_IF_MODIFIED_SINCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  152    152   
    ::aws_smithy_schema::ShapeId::from_static(
  153    153   
        "com.amazonaws.s3.synthetic#RenameObjectInput$DestinationIfModifiedSince",
  154    154   
        "com.amazonaws.s3.synthetic",
  155    155   
        "RenameObjectInput",
  156    156   
    ),
  157    157   
    ::aws_smithy_schema::ShapeType::Timestamp,
  158         -
    "destination_if_modified_since",
         158  +
    "DestinationIfModifiedSince",
  159    159   
    5,
  160    160   
)
  161    161   
.with_http_header("If-Modified-Since");
  162    162   
static RENAMEOBJECTINPUT_MEMBER_DESTINATION_IF_UNMODIFIED_SINCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  163    163   
    ::aws_smithy_schema::ShapeId::from_static(
  164    164   
        "com.amazonaws.s3.synthetic#RenameObjectInput$DestinationIfUnmodifiedSince",
  165    165   
        "com.amazonaws.s3.synthetic",
  166    166   
        "RenameObjectInput",
  167    167   
    ),
  168    168   
    ::aws_smithy_schema::ShapeType::Timestamp,
  169         -
    "destination_if_unmodified_since",
         169  +
    "DestinationIfUnmodifiedSince",
  170    170   
    6,
  171    171   
)
  172    172   
.with_http_header("If-Unmodified-Since");
  173    173   
static RENAMEOBJECTINPUT_MEMBER_SOURCE_IF_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  174    174   
    ::aws_smithy_schema::ShapeId::from_static(
  175    175   
        "com.amazonaws.s3.synthetic#RenameObjectInput$SourceIfMatch",
  176    176   
        "com.amazonaws.s3.synthetic",
  177    177   
        "RenameObjectInput",
  178    178   
    ),
  179    179   
    ::aws_smithy_schema::ShapeType::String,
  180         -
    "source_if_match",
         180  +
    "SourceIfMatch",
  181    181   
    7,
  182    182   
)
  183    183   
.with_http_header("x-amz-rename-source-if-match");
  184    184   
static RENAMEOBJECTINPUT_MEMBER_SOURCE_IF_NONE_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  185    185   
    ::aws_smithy_schema::ShapeId::from_static(
  186    186   
        "com.amazonaws.s3.synthetic#RenameObjectInput$SourceIfNoneMatch",
  187    187   
        "com.amazonaws.s3.synthetic",
  188    188   
        "RenameObjectInput",
  189    189   
    ),
  190    190   
    ::aws_smithy_schema::ShapeType::String,
  191         -
    "source_if_none_match",
         191  +
    "SourceIfNoneMatch",
  192    192   
    8,
  193    193   
)
  194    194   
.with_http_header("x-amz-rename-source-if-none-match");
  195    195   
static RENAMEOBJECTINPUT_MEMBER_SOURCE_IF_MODIFIED_SINCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  196    196   
    ::aws_smithy_schema::ShapeId::from_static(
  197    197   
        "com.amazonaws.s3.synthetic#RenameObjectInput$SourceIfModifiedSince",
  198    198   
        "com.amazonaws.s3.synthetic",
  199    199   
        "RenameObjectInput",
  200    200   
    ),
  201    201   
    ::aws_smithy_schema::ShapeType::Timestamp,
  202         -
    "source_if_modified_since",
         202  +
    "SourceIfModifiedSince",
  203    203   
    9,
  204    204   
)
  205         -
.with_http_header("x-amz-rename-source-if-modified-since");
         205  +
.with_http_header("x-amz-rename-source-if-modified-since")
         206  +
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::HttpDate);
  206    207   
static RENAMEOBJECTINPUT_MEMBER_SOURCE_IF_UNMODIFIED_SINCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  207    208   
    ::aws_smithy_schema::ShapeId::from_static(
  208    209   
        "com.amazonaws.s3.synthetic#RenameObjectInput$SourceIfUnmodifiedSince",
  209    210   
        "com.amazonaws.s3.synthetic",
  210    211   
        "RenameObjectInput",
  211    212   
    ),
  212    213   
    ::aws_smithy_schema::ShapeType::Timestamp,
  213         -
    "source_if_unmodified_since",
         214  +
    "SourceIfUnmodifiedSince",
  214    215   
    10,
  215    216   
)
  216         -
.with_http_header("x-amz-rename-source-if-unmodified-since");
         217  +
.with_http_header("x-amz-rename-source-if-unmodified-since")
         218  +
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::HttpDate);
  217    219   
static RENAMEOBJECTINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  218    220   
    ::aws_smithy_schema::ShapeId::from_static(
  219    221   
        "com.amazonaws.s3.synthetic#RenameObjectInput$ClientToken",
  220    222   
        "com.amazonaws.s3.synthetic",
  221    223   
        "RenameObjectInput",
  222    224   
    ),
  223    225   
    ::aws_smithy_schema::ShapeType::String,
  224         -
    "client_token",
         226  +
    "ClientToken",
  225    227   
    11,
  226    228   
)
  227    229   
.with_http_header("x-amz-client-token");
  228    230   
static RENAMEOBJECTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  229    231   
    RENAMEOBJECTINPUT_SCHEMA_ID,
  230    232   
    ::aws_smithy_schema::ShapeType::Structure,
  231    233   
    &[
  232    234   
        &RENAMEOBJECTINPUT_MEMBER_BUCKET,
  233    235   
        &RENAMEOBJECTINPUT_MEMBER_KEY,
  234    236   
        &RENAMEOBJECTINPUT_MEMBER_RENAME_SOURCE,
  235    237   
        &RENAMEOBJECTINPUT_MEMBER_DESTINATION_IF_MATCH,
  236    238   
        &RENAMEOBJECTINPUT_MEMBER_DESTINATION_IF_NONE_MATCH,
  237    239   
        &RENAMEOBJECTINPUT_MEMBER_DESTINATION_IF_MODIFIED_SINCE,
  238    240   
        &RENAMEOBJECTINPUT_MEMBER_DESTINATION_IF_UNMODIFIED_SINCE,
  239    241   
        &RENAMEOBJECTINPUT_MEMBER_SOURCE_IF_MATCH,
  240    242   
        &RENAMEOBJECTINPUT_MEMBER_SOURCE_IF_NONE_MATCH,
  241    243   
        &RENAMEOBJECTINPUT_MEMBER_SOURCE_IF_MODIFIED_SINCE,
  242    244   
        &RENAMEOBJECTINPUT_MEMBER_SOURCE_IF_UNMODIFIED_SINCE,
  243    245   
        &RENAMEOBJECTINPUT_MEMBER_CLIENT_TOKEN,
  244    246   
    ],
  245         -
);
         247  +
)
         248  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/{Key+}?renameObject", None));
  246    249   
impl RenameObjectInput {
  247    250   
    /// The schema for this shape.
  248    251   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RENAMEOBJECTINPUT_SCHEMA;
  249    252   
}
  250    253   
impl ::aws_smithy_schema::serde::SerializableStruct for RenameObjectInput {
  251    254   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  252    255   
    fn serialize_members(
  253    256   
        &self,
  254    257   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  255    258   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  256    259   
        if let Some(ref val) = self.bucket {
  257    260   
            ser.write_string(&RENAMEOBJECTINPUT_MEMBER_BUCKET, val)?;
  258    261   
        }
  259    262   
        if let Some(ref val) = self.key {
  260    263   
            ser.write_string(&RENAMEOBJECTINPUT_MEMBER_KEY, val)?;
  261    264   
        }
  262    265   
        if let Some(ref val) = self.rename_source {
  263    266   
            ser.write_string(&RENAMEOBJECTINPUT_MEMBER_RENAME_SOURCE, val)?;
  264    267   
        }
  265    268   
        if let Some(ref val) = self.destination_if_match {
  266    269   
            ser.write_string(&RENAMEOBJECTINPUT_MEMBER_DESTINATION_IF_MATCH, val)?;
  267    270   
        }
  268    271   
        if let Some(ref val) = self.destination_if_none_match {
  269    272   
            ser.write_string(&RENAMEOBJECTINPUT_MEMBER_DESTINATION_IF_NONE_MATCH, val)?;
  270    273   
        }
  271    274   
        if let Some(ref val) = self.destination_if_modified_since {
  272    275   
            ser.write_timestamp(&RENAMEOBJECTINPUT_MEMBER_DESTINATION_IF_MODIFIED_SINCE, val)?;
  273    276   
        }
  274    277   
        if let Some(ref val) = self.destination_if_unmodified_since {
  275    278   
            ser.write_timestamp(&RENAMEOBJECTINPUT_MEMBER_DESTINATION_IF_UNMODIFIED_SINCE, val)?;
  276    279   
        }
  277    280   
        if let Some(ref val) = self.source_if_match {
  278    281   
            ser.write_string(&RENAMEOBJECTINPUT_MEMBER_SOURCE_IF_MATCH, val)?;
  279    282   
        }
  280    283   
        if let Some(ref val) = self.source_if_none_match {
  281    284   
            ser.write_string(&RENAMEOBJECTINPUT_MEMBER_SOURCE_IF_NONE_MATCH, val)?;
  282    285   
        }
  283    286   
        if let Some(ref val) = self.source_if_modified_since {
  284    287   
            ser.write_timestamp(&RENAMEOBJECTINPUT_MEMBER_SOURCE_IF_MODIFIED_SINCE, val)?;
  285    288   
        }
  286    289   
        if let Some(ref val) = self.source_if_unmodified_since {
  287    290   
            ser.write_timestamp(&RENAMEOBJECTINPUT_MEMBER_SOURCE_IF_UNMODIFIED_SINCE, val)?;
  288    291   
        }
  289    292   
        if let Some(ref val) = self.client_token {
  290    293   
            ser.write_string(&RENAMEOBJECTINPUT_MEMBER_CLIENT_TOKEN, val)?;
  291    294   
        }
  292    295   
        Ok(())
  293    296   
    }
  294    297   
}
  295    298   
impl RenameObjectInput {
  296    299   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  297         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  298         -
        deserializer: &mut D,
         300  +
    pub fn deserialize(
         301  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  299    302   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  300    303   
        #[allow(unused_variables, unused_mut)]
  301    304   
        let mut builder = Self::builder();
  302    305   
        #[allow(
  303    306   
            unused_variables,
  304    307   
            unreachable_code,
  305    308   
            clippy::single_match,
  306    309   
            clippy::match_single_binding,
  307    310   
            clippy::diverging_sub_expression
  308    311   
        )]
  309         -
        deserializer.read_struct(&RENAMEOBJECTINPUT_SCHEMA, (), |_, member, deser| {
         312  +
        deserializer.read_struct(&RENAMEOBJECTINPUT_SCHEMA, &mut |member, deser| {
  310    313   
            match member.member_index() {
  311    314   
                Some(0) => {
  312    315   
                    builder.bucket = Some(deser.read_string(member)?);
  313    316   
                }
  314    317   
                Some(1) => {
  315    318   
                    builder.key = Some(deser.read_string(member)?);
  316    319   
                }
  317    320   
                Some(2) => {
  318    321   
                    builder.rename_source = Some(deser.read_string(member)?);
  319    322   
                }
  320    323   
                Some(3) => {
  321    324   
                    builder.destination_if_match = Some(deser.read_string(member)?);
  322    325   
                }
  323    326   
                Some(4) => {
  324    327   
                    builder.destination_if_none_match = Some(deser.read_string(member)?);
  325    328   
                }
  326    329   
                Some(5) => {
  327    330   
                    builder.destination_if_modified_since = Some(deser.read_timestamp(member)?);
  328    331   
                }
  329    332   
                Some(6) => {
  330    333   
                    builder.destination_if_unmodified_since = Some(deser.read_timestamp(member)?);
  331    334   
                }
  332    335   
                Some(7) => {
  333    336   
                    builder.source_if_match = Some(deser.read_string(member)?);
  334    337   
                }
  335    338   
                Some(8) => {
  336    339   
                    builder.source_if_none_match = Some(deser.read_string(member)?);
  337    340   
                }
  338    341   
                Some(9) => {
  339    342   
                    builder.source_if_modified_since = Some(deser.read_timestamp(member)?);
  340    343   
                }
  341    344   
                Some(10) => {
  342    345   
                    builder.source_if_unmodified_since = Some(deser.read_timestamp(member)?);
  343    346   
                }
  344    347   
                Some(11) => {
  345    348   
                    builder.client_token = Some(deser.read_string(member)?);
  346    349   
                }
  347    350   
                _ => {}
  348    351   
            }
  349    352   
            Ok(())
  350    353   
        })?;
         354  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         355  +
        builder.key = builder.key.or(Some(String::new()));
         356  +
        builder.rename_source = builder.rename_source.or(Some(String::new()));
         357  +
        builder
         358  +
            .build()
         359  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         360  +
    }
         361  +
}
         362  +
impl RenameObjectInput {
         363  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         364  +
    /// Header-bound members are read directly from headers, avoiding runtime
         365  +
    /// member iteration overhead. Body members are read via the deserializer.
         366  +
    pub fn deserialize_with_response(
         367  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         368  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         369  +
        _status: u16,
         370  +
        _body: &[u8],
         371  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         372  +
        #[allow(unused_variables, unused_mut)]
         373  +
        let mut builder = Self::builder();
         374  +
        if let Some(val) = headers.get("x-amz-rename-source") {
         375  +
            builder.rename_source = Some(val.to_string());
         376  +
        }
         377  +
        if let Some(val) = headers.get("If-Match") {
         378  +
            builder.destination_if_match = Some(val.to_string());
         379  +
        }
         380  +
        if let Some(val) = headers.get("If-None-Match") {
         381  +
            builder.destination_if_none_match = Some(val.to_string());
         382  +
        }
         383  +
        if let Some(val) = headers.get("If-Modified-Since") {
         384  +
            builder.destination_if_modified_since = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
         385  +
        }
         386  +
        if let Some(val) = headers.get("If-Unmodified-Since") {
         387  +
            builder.destination_if_unmodified_since =
         388  +
                ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
         389  +
        }
         390  +
        if let Some(val) = headers.get("x-amz-rename-source-if-match") {
         391  +
            builder.source_if_match = Some(val.to_string());
         392  +
        }
         393  +
        if let Some(val) = headers.get("x-amz-rename-source-if-none-match") {
         394  +
            builder.source_if_none_match = Some(val.to_string());
         395  +
        }
         396  +
        if let Some(val) = headers.get("x-amz-rename-source-if-modified-since") {
         397  +
            builder.source_if_modified_since = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
         398  +
        }
         399  +
        if let Some(val) = headers.get("x-amz-rename-source-if-unmodified-since") {
         400  +
            builder.source_if_unmodified_since = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
         401  +
        }
         402  +
        if let Some(val) = headers.get("x-amz-client-token") {
         403  +
            builder.client_token = Some(val.to_string());
         404  +
        }
         405  +
        #[allow(
         406  +
            unused_variables,
         407  +
            unreachable_code,
         408  +
            clippy::single_match,
         409  +
            clippy::match_single_binding,
         410  +
            clippy::diverging_sub_expression
         411  +
        )]
         412  +
        deserializer.read_struct(&RENAMEOBJECTINPUT_SCHEMA, &mut |member, deser| {
         413  +
            match member.member_index() {
         414  +
                Some(0) => {
         415  +
                    builder.bucket = Some(deser.read_string(member)?);
         416  +
                }
         417  +
                Some(1) => {
         418  +
                    builder.key = Some(deser.read_string(member)?);
         419  +
                }
         420  +
                Some(2) => { /* read from headers above */ }
         421  +
                Some(3) => { /* read from headers above */ }
         422  +
                Some(4) => { /* read from headers above */ }
         423  +
                Some(5) => { /* read from headers above */ }
         424  +
                Some(6) => { /* read from headers above */ }
         425  +
                Some(7) => { /* read from headers above */ }
         426  +
                Some(8) => { /* read from headers above */ }
         427  +
                Some(9) => { /* read from headers above */ }
         428  +
                Some(10) => { /* read from headers above */ }
         429  +
                Some(11) => { /* read from headers above */ }
         430  +
                _ => {}
         431  +
            }
         432  +
            Ok(())
         433  +
        })?;
  351    434   
        builder
  352    435   
            .build()
  353    436   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  354    437   
    }
  355    438   
}
  356    439   
impl RenameObjectInput {
  357    440   
    /// Creates a new builder-style object to manufacture [`RenameObjectInput`](crate::operation::rename_object::RenameObjectInput).
  358    441   
    pub fn builder() -> crate::operation::rename_object::builders::RenameObjectInputBuilder {
  359    442   
        crate::operation::rename_object::builders::RenameObjectInputBuilder::default()
  360    443   
    }

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

@@ -1,1 +81,112 @@
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5      5   
pub struct RenameObjectOutput {
    6      6   
    _extended_request_id: Option<String>,
    7      7   
    _request_id: Option<String>,
    8      8   
}
    9      9   
static RENAMEOBJECTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
   10     10   
    "com.amazonaws.s3.synthetic#RenameObjectOutput",
   11     11   
    "com.amazonaws.s3.synthetic",
   12     12   
    "RenameObjectOutput",
   13     13   
);
   14         -
static RENAMEOBJECTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
   15         -
    ::aws_smithy_schema::Schema::new_struct(RENAMEOBJECTOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
          14  +
static RENAMEOBJECTOUTPUT_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 RENAMEOBJECTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
          22  +
    RENAMEOBJECTOUTPUT_SCHEMA_ID,
          23  +
    ::aws_smithy_schema::ShapeType::Structure,
          24  +
    &[&RENAMEOBJECTOUTPUT_MEMBER__REQUEST_ID],
          25  +
);
   16     26   
impl RenameObjectOutput {
   17     27   
    /// The schema for this shape.
   18     28   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RENAMEOBJECTOUTPUT_SCHEMA;
   19     29   
}
   20     30   
impl ::aws_smithy_schema::serde::SerializableStruct for RenameObjectOutput {
   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 RenameObjectOutput {
   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(&RENAMEOBJECTOUTPUT_SCHEMA, (), |_, member, deser| {
          53  +
        deserializer.read_struct(&RENAMEOBJECTOUTPUT_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 RenameObjectOutput {
          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 RenameObjectOutput {
   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 RenameObjectOutput {
   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/restore_object.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 `RestoreObject`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct RestoreObject;
    6      6   
impl RestoreObject {
    7      7   
    /// Creates a new `RestoreObject`
    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::restore_object::RestoreObjectInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::restore_object::RestoreObjectOutput::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::restore_object::RestoreObjectInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::restore_object::RestoreObjectOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::restore_object::RestoreObjectError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -182,186 +241,246 @@
  202    206   
        ::std::borrow::Cow::Owned(rcb)
  203    207   
    }
  204    208   
}
  205    209   
  206    210   
#[derive(Debug)]
  207    211   
struct RestoreObjectResponseDeserializer;
  208    212   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RestoreObjectResponseDeserializer {
  209    213   
    fn deserialize_nonstreaming(
  210    214   
        &self,
  211    215   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         216  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  212    217   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  213    218   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  214    219   
        let headers = response.headers();
  215    220   
        let body = response.body().bytes().expect("body loaded");
  216    221   
        #[allow(unused_mut)]
  217    222   
        let mut force_error = false;
  218    223   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  219    224   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  220    225   
            force_error = true;
  221    226   
        }

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

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

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

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/select_object_content.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 `SelectObjectContent`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct SelectObjectContent;
    6      6   
impl SelectObjectContent {
    7      7   
    /// Creates a new `SelectObjectContent`
    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::select_object_content::SelectObjectContentInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::select_object_content::SelectObjectContentOutput::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::select_object_content::SelectObjectContentInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::select_object_content::SelectObjectContentOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::select_object_content::SelectObjectContentError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -133,137 +192,197 @@
  153    157   
            return ::std::option::Option::None;
  154    158   
        }
  155    159   
        ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
  156    160   
            crate::protocol_serde::shape_select_object_content::de_select_object_content_http_response(response),
  157    161   
        ))
  158    162   
    }
  159    163   
  160    164   
    fn deserialize_nonstreaming(
  161    165   
        &self,
  162    166   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         167  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  163    168   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  164    169   
        // For streaming operations, we only hit this case if its an error
  165    170   
        let body = response.body().bytes().expect("body loaded");
  166    171   
        crate::protocol_serde::type_erase_result(crate::protocol_serde::shape_select_object_content::de_select_object_content_http_error(
  167    172   
            response.status().as_u16(),
  168    173   
            response.headers(),
  169    174   
            body,
  170    175   
        ))
  171    176   
    }
  172    177   
}

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

@@ -133,133 +434,508 @@
  153    153   
    "com.amazonaws.s3.synthetic",
  154    154   
    "SelectObjectContentInput",
  155    155   
);
  156    156   
static SELECTOBJECTCONTENTINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  157    157   
    ::aws_smithy_schema::ShapeId::from_static(
  158    158   
        "com.amazonaws.s3.synthetic#SelectObjectContentInput$Bucket",
  159    159   
        "com.amazonaws.s3.synthetic",
  160    160   
        "SelectObjectContentInput",
  161    161   
    ),
  162    162   
    ::aws_smithy_schema::ShapeType::String,
  163         -
    "bucket",
         163  +
    "Bucket",
  164    164   
    0,
  165    165   
)
  166    166   
.with_http_label();
  167    167   
static SELECTOBJECTCONTENTINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  168    168   
    ::aws_smithy_schema::ShapeId::from_static(
  169    169   
        "com.amazonaws.s3.synthetic#SelectObjectContentInput$Key",
  170    170   
        "com.amazonaws.s3.synthetic",
  171    171   
        "SelectObjectContentInput",
  172    172   
    ),
  173    173   
    ::aws_smithy_schema::ShapeType::String,
  174         -
    "key",
         174  +
    "Key",
  175    175   
    1,
  176    176   
)
  177    177   
.with_http_label();
  178    178   
static SELECTOBJECTCONTENTINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static(
  180    180   
        "com.amazonaws.s3.synthetic#SelectObjectContentInput$SSECustomerAlgorithm",
  181    181   
        "com.amazonaws.s3.synthetic",
  182    182   
        "SelectObjectContentInput",
  183    183   
    ),
  184    184   
    ::aws_smithy_schema::ShapeType::String,
  185         -
    "sse_customer_algorithm",
         185  +
    "SSECustomerAlgorithm",
  186    186   
    2,
  187    187   
)
  188    188   
.with_http_header("x-amz-server-side-encryption-customer-algorithm");
  189    189   
static SELECTOBJECTCONTENTINPUT_MEMBER_SSE_CUSTOMER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  190    190   
    ::aws_smithy_schema::ShapeId::from_static(
  191    191   
        "com.amazonaws.s3.synthetic#SelectObjectContentInput$SSECustomerKey",
  192    192   
        "com.amazonaws.s3.synthetic",
  193    193   
        "SelectObjectContentInput",
  194    194   
    ),
  195    195   
    ::aws_smithy_schema::ShapeType::String,
  196         -
    "sse_customer_key",
         196  +
    "SSECustomerKey",
  197    197   
    3,
  198    198   
)
  199    199   
.with_http_header("x-amz-server-side-encryption-customer-key");
  200    200   
static SELECTOBJECTCONTENTINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  201    201   
    ::aws_smithy_schema::ShapeId::from_static(
  202    202   
        "com.amazonaws.s3.synthetic#SelectObjectContentInput$SSECustomerKeyMD5",
  203    203   
        "com.amazonaws.s3.synthetic",
  204    204   
        "SelectObjectContentInput",
  205    205   
    ),
  206    206   
    ::aws_smithy_schema::ShapeType::String,
  207         -
    "sse_customer_key_md5",
         207  +
    "SSECustomerKeyMD5",
  208    208   
    4,
  209    209   
)
  210    210   
.with_http_header("x-amz-server-side-encryption-customer-key-MD5");
  211    211   
static SELECTOBJECTCONTENTINPUT_MEMBER_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  212    212   
    ::aws_smithy_schema::ShapeId::from_static(
  213    213   
        "com.amazonaws.s3.synthetic#SelectObjectContentInput$Expression",
  214    214   
        "com.amazonaws.s3.synthetic",
  215    215   
        "SelectObjectContentInput",
  216    216   
    ),
  217    217   
    ::aws_smithy_schema::ShapeType::String,
  218         -
    "expression",
         218  +
    "Expression",
  219    219   
    5,
  220    220   
);
  221    221   
static SELECTOBJECTCONTENTINPUT_MEMBER_EXPRESSION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  222    222   
    ::aws_smithy_schema::ShapeId::from_static(
  223    223   
        "com.amazonaws.s3.synthetic#SelectObjectContentInput$ExpressionType",
  224    224   
        "com.amazonaws.s3.synthetic",
  225    225   
        "SelectObjectContentInput",
  226    226   
    ),
  227    227   
    ::aws_smithy_schema::ShapeType::String,
  228         -
    "expression_type",
         228  +
    "ExpressionType",
  229    229   
    6,
  230    230   
);
  231    231   
static SELECTOBJECTCONTENTINPUT_MEMBER_REQUEST_PROGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  232    232   
    ::aws_smithy_schema::ShapeId::from_static(
  233    233   
        "com.amazonaws.s3.synthetic#SelectObjectContentInput$RequestProgress",
  234    234   
        "com.amazonaws.s3.synthetic",
  235    235   
        "SelectObjectContentInput",
  236    236   
    ),
  237    237   
    ::aws_smithy_schema::ShapeType::Structure,
  238         -
    "request_progress",
         238  +
    "RequestProgress",
  239    239   
    7,
  240    240   
);
  241    241   
static SELECTOBJECTCONTENTINPUT_MEMBER_INPUT_SERIALIZATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  242    242   
    ::aws_smithy_schema::ShapeId::from_static(
  243    243   
        "com.amazonaws.s3.synthetic#SelectObjectContentInput$InputSerialization",
  244    244   
        "com.amazonaws.s3.synthetic",
  245    245   
        "SelectObjectContentInput",
  246    246   
    ),
  247    247   
    ::aws_smithy_schema::ShapeType::Structure,
  248         -
    "input_serialization",
         248  +
    "InputSerialization",
  249    249   
    8,
  250    250   
);
  251    251   
static SELECTOBJECTCONTENTINPUT_MEMBER_OUTPUT_SERIALIZATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  252    252   
    ::aws_smithy_schema::ShapeId::from_static(
  253    253   
        "com.amazonaws.s3.synthetic#SelectObjectContentInput$OutputSerialization",
  254    254   
        "com.amazonaws.s3.synthetic",
  255    255   
        "SelectObjectContentInput",
  256    256   
    ),
  257    257   
    ::aws_smithy_schema::ShapeType::Structure,
  258         -
    "output_serialization",
         258  +
    "OutputSerialization",
  259    259   
    9,
  260    260   
);
  261    261   
static SELECTOBJECTCONTENTINPUT_MEMBER_SCAN_RANGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  262    262   
    ::aws_smithy_schema::ShapeId::from_static(
  263    263   
        "com.amazonaws.s3.synthetic#SelectObjectContentInput$ScanRange",
  264    264   
        "com.amazonaws.s3.synthetic",
  265    265   
        "SelectObjectContentInput",
  266    266   
    ),
  267    267   
    ::aws_smithy_schema::ShapeType::Structure,
  268         -
    "scan_range",
         268  +
    "ScanRange",
  269    269   
    10,
  270    270   
);
  271    271   
static SELECTOBJECTCONTENTINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  272    272   
    ::aws_smithy_schema::ShapeId::from_static(
  273    273   
        "com.amazonaws.s3.synthetic#SelectObjectContentInput$ExpectedBucketOwner",
  274    274   
        "com.amazonaws.s3.synthetic",
  275    275   
        "SelectObjectContentInput",
  276    276   
    ),
  277    277   
    ::aws_smithy_schema::ShapeType::String,
  278         -
    "expected_bucket_owner",
         278  +
    "ExpectedBucketOwner",
  279    279   
    11,
  280    280   
)
  281    281   
.with_http_header("x-amz-expected-bucket-owner");
  282    282   
static SELECTOBJECTCONTENTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  283    283   
    SELECTOBJECTCONTENTINPUT_SCHEMA_ID,
  284    284   
    ::aws_smithy_schema::ShapeType::Structure,
  285    285   
    &[
  286    286   
        &SELECTOBJECTCONTENTINPUT_MEMBER_BUCKET,
  287    287   
        &SELECTOBJECTCONTENTINPUT_MEMBER_KEY,
  288    288   
        &SELECTOBJECTCONTENTINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
  289    289   
        &SELECTOBJECTCONTENTINPUT_MEMBER_SSE_CUSTOMER_KEY,
  290    290   
        &SELECTOBJECTCONTENTINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
  291    291   
        &SELECTOBJECTCONTENTINPUT_MEMBER_EXPRESSION,
  292    292   
        &SELECTOBJECTCONTENTINPUT_MEMBER_EXPRESSION_TYPE,
  293    293   
        &SELECTOBJECTCONTENTINPUT_MEMBER_REQUEST_PROGRESS,
  294    294   
        &SELECTOBJECTCONTENTINPUT_MEMBER_INPUT_SERIALIZATION,
  295    295   
        &SELECTOBJECTCONTENTINPUT_MEMBER_OUTPUT_SERIALIZATION,
  296    296   
        &SELECTOBJECTCONTENTINPUT_MEMBER_SCAN_RANGE,
  297    297   
        &SELECTOBJECTCONTENTINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
  298    298   
    ],
  299         -
);
         299  +
)
         300  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/{Key+}?select&select-type=2", None));
  300    301   
impl SelectObjectContentInput {
  301    302   
    /// The schema for this shape.
  302    303   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SELECTOBJECTCONTENTINPUT_SCHEMA;
  303    304   
}
  304    305   
impl ::aws_smithy_schema::serde::SerializableStruct for SelectObjectContentInput {
  305    306   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  306    307   
    fn serialize_members(
  307    308   
        &self,
  308    309   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  309    310   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  310    311   
        if let Some(ref val) = self.bucket {
  311    312   
            ser.write_string(&SELECTOBJECTCONTENTINPUT_MEMBER_BUCKET, val)?;
  312    313   
        }
  313    314   
        if let Some(ref val) = self.key {
  314    315   
            ser.write_string(&SELECTOBJECTCONTENTINPUT_MEMBER_KEY, val)?;
  315    316   
        }
  316    317   
        if let Some(ref val) = self.sse_customer_algorithm {
  317    318   
            ser.write_string(&SELECTOBJECTCONTENTINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM, val)?;
  318    319   
        }
  319    320   
        if let Some(ref val) = self.sse_customer_key {
  320    321   
            ser.write_string(&SELECTOBJECTCONTENTINPUT_MEMBER_SSE_CUSTOMER_KEY, val)?;
  321    322   
        }
  322    323   
        if let Some(ref val) = self.sse_customer_key_md5 {
  323    324   
            ser.write_string(&SELECTOBJECTCONTENTINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5, val)?;
  324    325   
        }
  325    326   
        if let Some(ref val) = self.expression {
  326    327   
            ser.write_string(&SELECTOBJECTCONTENTINPUT_MEMBER_EXPRESSION, val)?;
  327    328   
        }
  328    329   
        if let Some(ref val) = self.expression_type {
  329    330   
            ser.write_string(&SELECTOBJECTCONTENTINPUT_MEMBER_EXPRESSION_TYPE, val.as_str())?;
  330    331   
        }
  331    332   
        if let Some(ref val) = self.request_progress {
  332    333   
            ser.write_struct(&SELECTOBJECTCONTENTINPUT_MEMBER_REQUEST_PROGRESS, val)?;
  333    334   
        }
  334    335   
        if let Some(ref val) = self.input_serialization {
  335    336   
            ser.write_struct(&SELECTOBJECTCONTENTINPUT_MEMBER_INPUT_SERIALIZATION, val)?;
  336    337   
        }
  337    338   
        if let Some(ref val) = self.output_serialization {
  338    339   
            ser.write_struct(&SELECTOBJECTCONTENTINPUT_MEMBER_OUTPUT_SERIALIZATION, val)?;
  339    340   
        }
  340    341   
        if let Some(ref val) = self.scan_range {
  341    342   
            ser.write_struct(&SELECTOBJECTCONTENTINPUT_MEMBER_SCAN_RANGE, val)?;
  342    343   
        }
  343    344   
        if let Some(ref val) = self.expected_bucket_owner {
  344    345   
            ser.write_string(&SELECTOBJECTCONTENTINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
  345    346   
        }
  346    347   
        Ok(())
  347    348   
    }
  348    349   
}
  349    350   
impl SelectObjectContentInput {
  350    351   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  351         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  352         -
        deserializer: &mut D,
         352  +
    pub fn deserialize(
         353  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  353    354   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  354    355   
        #[allow(unused_variables, unused_mut)]
  355    356   
        let mut builder = Self::builder();
  356    357   
        #[allow(
  357    358   
            unused_variables,
  358    359   
            unreachable_code,
  359    360   
            clippy::single_match,
  360    361   
            clippy::match_single_binding,
  361    362   
            clippy::diverging_sub_expression
  362    363   
        )]
  363         -
        deserializer.read_struct(&SELECTOBJECTCONTENTINPUT_SCHEMA, (), |_, member, deser| {
         364  +
        deserializer.read_struct(&SELECTOBJECTCONTENTINPUT_SCHEMA, &mut |member, deser| {
  364    365   
            match member.member_index() {
  365    366   
                Some(0) => {
  366    367   
                    builder.bucket = Some(deser.read_string(member)?);
  367    368   
                }
  368    369   
                Some(1) => {
  369    370   
                    builder.key = Some(deser.read_string(member)?);
  370    371   
                }
  371    372   
                Some(2) => {
  372    373   
                    builder.sse_customer_algorithm = Some(deser.read_string(member)?);
  373    374   
                }
  374    375   
                Some(3) => {
  375    376   
                    builder.sse_customer_key = Some(deser.read_string(member)?);
  376    377   
                }
  377    378   
                Some(4) => {
  378    379   
                    builder.sse_customer_key_md5 = Some(deser.read_string(member)?);
  379    380   
                }
  380    381   
                Some(5) => {
  381    382   
                    builder.expression = Some(deser.read_string(member)?);
  382    383   
                }
  383    384   
                Some(6) => {
  384    385   
                    builder.expression_type = Some(crate::types::ExpressionType::from(deser.read_string(member)?.as_str()));
  385    386   
                }
  386    387   
                Some(7) => {
  387    388   
                    builder.request_progress = Some(crate::types::RequestProgress::deserialize(deser)?);
  388    389   
                }
  389    390   
                Some(8) => {
  390    391   
                    builder.input_serialization = Some(crate::types::InputSerialization::deserialize(deser)?);
  391    392   
                }
  392    393   
                Some(9) => {
  393    394   
                    builder.output_serialization = Some(crate::types::OutputSerialization::deserialize(deser)?);
  394    395   
                }
  395    396   
                Some(10) => {
  396    397   
                    builder.scan_range = Some(crate::types::ScanRange::deserialize(deser)?);
  397    398   
                }
  398    399   
                Some(11) => {
  399    400   
                    builder.expected_bucket_owner = Some(deser.read_string(member)?);
  400    401   
                }
  401    402   
                _ => {}
  402    403   
            }
  403    404   
            Ok(())
  404    405   
        })?;
         406  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         407  +
        builder.key = builder.key.or(Some(String::new()));
         408  +
        builder.expression = builder.expression.or(Some(String::new()));
         409  +
        builder
         410  +
            .build()
         411  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         412  +
    }
         413  +
}
         414  +
impl SelectObjectContentInput {
         415  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         416  +
    /// Header-bound members are read directly from headers, avoiding runtime
         417  +
    /// member iteration overhead. Body members are read via the deserializer.
         418  +
    pub fn deserialize_with_response(
         419  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         420  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         421  +
        _status: u16,
         422  +
        _body: &[u8],
         423  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         424  +
        #[allow(unused_variables, unused_mut)]
         425  +
        let mut builder = Self::builder();
         426  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
         427  +
            builder.sse_customer_algorithm = Some(val.to_string());
         428  +
        }
         429  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key") {
         430  +
            builder.sse_customer_key = Some(val.to_string());
         431  +
        }
         432  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
         433  +
            builder.sse_customer_key_md5 = Some(val.to_string());
         434  +
        }
         435  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         436  +
            builder.expected_bucket_owner = Some(val.to_string());
         437  +
        }
         438  +
        #[allow(
         439  +
            unused_variables,
         440  +
            unreachable_code,
         441  +
            clippy::single_match,
         442  +
            clippy::match_single_binding,
         443  +
            clippy::diverging_sub_expression
         444  +
        )]
         445  +
        deserializer.read_struct(&SELECTOBJECTCONTENTINPUT_SCHEMA, &mut |member, deser| {
         446  +
            match member.member_index() {
         447  +
                Some(0) => {
         448  +
                    builder.bucket = Some(deser.read_string(member)?);
         449  +
                }
         450  +
                Some(1) => {
         451  +
                    builder.key = Some(deser.read_string(member)?);
         452  +
                }
         453  +
                Some(2) => { /* read from headers above */ }
         454  +
                Some(3) => { /* read from headers above */ }
         455  +
                Some(4) => { /* read from headers above */ }
         456  +
                Some(5) => {
         457  +
                    builder.expression = Some(deser.read_string(member)?);
         458  +
                }
         459  +
                Some(6) => {
         460  +
                    builder.expression_type = Some(crate::types::ExpressionType::from(deser.read_string(member)?.as_str()));
         461  +
                }
         462  +
                Some(7) => {
         463  +
                    builder.request_progress = Some(crate::types::RequestProgress::deserialize(deser)?);
         464  +
                }
         465  +
                Some(8) => {
         466  +
                    builder.input_serialization = Some(crate::types::InputSerialization::deserialize(deser)?);
         467  +
                }
         468  +
                Some(9) => {
         469  +
                    builder.output_serialization = Some(crate::types::OutputSerialization::deserialize(deser)?);
         470  +
                }
         471  +
                Some(10) => {
         472  +
                    builder.scan_range = Some(crate::types::ScanRange::deserialize(deser)?);
         473  +
                }
         474  +
                Some(11) => { /* read from headers above */ }
         475  +
                _ => {}
         476  +
            }
         477  +
            Ok(())
         478  +
        })?;
  405    479   
        builder
  406    480   
            .build()
  407    481   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  408    482   
    }
  409    483   
}
  410    484   
impl SelectObjectContentInput {
  411    485   
    /// Creates a new builder-style object to manufacture [`SelectObjectContentInput`](crate::operation::select_object_content::SelectObjectContentInput).
  412    486   
    pub fn builder() -> crate::operation::select_object_content::builders::SelectObjectContentInputBuilder {
  413    487   
        crate::operation::select_object_content::builders::SelectObjectContentInputBuilder::default()
  414    488   
    }

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

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