AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406

Files changed:

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

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

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

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_object_torrent.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 `GetObjectTorrent`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetObjectTorrent;
    6      6   
impl GetObjectTorrent {
    7      7   
    /// Creates a new `GetObjectTorrent`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_object_torrent::GetObjectTorrentInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_object_torrent::GetObjectTorrentOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::get_object_torrent::GetObjectTorrentInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_object_torrent::GetObjectTorrentOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_object_torrent::GetObjectTorrentError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -139,143 +201,206 @@
  159    163   
  160    164   
        // If this is an error, defer to the non-streaming parser
  161    165   
        if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {
  162    166   
            return ::std::option::Option::None;
  163    167   
        }
  164    168   
        ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
  165    169   
            crate::protocol_serde::shape_get_object_torrent::de_get_object_torrent_http_response(response),
  166    170   
        ))
  167    171   
    }
  168    172   
  169         -
    fn deserialize_nonstreaming(
         173  +
    fn deserialize_nonstreaming_with_config(
  170    174   
        &self,
  171    175   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         176  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  172    177   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  173    178   
        // For streaming operations, we only hit this case if its an error
  174    179   
        let body = response.body().bytes().expect("body loaded");
  175    180   
        crate::protocol_serde::type_erase_result(crate::protocol_serde::shape_get_object_torrent::de_get_object_torrent_http_error(
  176    181   
            response.status().as_u16(),
  177    182   
            response.headers(),
  178    183   
            body,
  179    184   
        ))
  180    185   
    }
  181    186   
}

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

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

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

@@ -9,9 +133,184 @@
   29     29   
    "com.amazonaws.s3.synthetic",
   30     30   
    "GetObjectTorrentOutput",
   31     31   
);
   32     32   
static GETOBJECTTORRENTOUTPUT_MEMBER_BODY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static(
   34     34   
        "com.amazonaws.s3.synthetic#GetObjectTorrentOutput$Body",
   35     35   
        "com.amazonaws.s3.synthetic",
   36     36   
        "GetObjectTorrentOutput",
   37     37   
    ),
   38     38   
    ::aws_smithy_schema::ShapeType::Blob,
   39         -
    "body",
          39  +
    "Body",
   40     40   
    0,
   41     41   
)
   42     42   
.with_http_payload();
   43     43   
static GETOBJECTTORRENTOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.s3.synthetic#GetObjectTorrentOutput$RequestCharged",
   46     46   
        "com.amazonaws.s3.synthetic",
   47     47   
        "GetObjectTorrentOutput",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "request_charged",
          50  +
    "RequestCharged",
   51     51   
    1,
   52     52   
)
   53     53   
.with_http_header("x-amz-request-charged");
          54  +
static GETOBJECTTORRENTOUTPUT_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 GETOBJECTTORRENTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   55     62   
    GETOBJECTTORRENTOUTPUT_SCHEMA_ID,
   56     63   
    ::aws_smithy_schema::ShapeType::Structure,
   57         -
    &[&GETOBJECTTORRENTOUTPUT_MEMBER_BODY, &GETOBJECTTORRENTOUTPUT_MEMBER_REQUEST_CHARGED],
          64  +
    &[
          65  +
        &GETOBJECTTORRENTOUTPUT_MEMBER_BODY,
          66  +
        &GETOBJECTTORRENTOUTPUT_MEMBER_REQUEST_CHARGED,
          67  +
        &GETOBJECTTORRENTOUTPUT_MEMBER__REQUEST_ID,
          68  +
    ],
   58     69   
);
   59     70   
impl GetObjectTorrentOutput {
   60     71   
    /// The schema for this shape.
   61     72   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETOBJECTTORRENTOUTPUT_SCHEMA;
   62     73   
}
   63     74   
impl ::aws_smithy_schema::serde::SerializableStruct for GetObjectTorrentOutput {
   64     75   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   65     76   
    fn serialize_members(
   66     77   
        &self,
   67     78   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   68     79   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   69         -
        {
   70         -
            let val = &self.body;
   71         -
            // streaming blob is serialized as the HTTP body by the protocol, not the codec
   72         -
        }
   73     80   
        if let Some(ref val) = self.request_charged {
   74     81   
            ser.write_string(&GETOBJECTTORRENTOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
   75     82   
        }
   76     83   
        Ok(())
   77     84   
    }
   78     85   
}
   79     86   
impl GetObjectTorrentOutput {
   80     87   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   81         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   82         -
        deserializer: &mut D,
          88  +
    pub fn deserialize(
          89  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   83     90   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   84     91   
        #[allow(unused_variables, unused_mut)]
   85     92   
        let mut builder = Self::builder();
   86     93   
        #[allow(
   87     94   
            unused_variables,
   88     95   
            unreachable_code,
   89     96   
            clippy::single_match,
   90     97   
            clippy::match_single_binding,
   91     98   
            clippy::diverging_sub_expression
   92     99   
        )]
   93         -
        deserializer.read_struct(&GETOBJECTTORRENTOUTPUT_SCHEMA, (), |_, member, deser| {
         100  +
        deserializer.read_struct(&GETOBJECTTORRENTOUTPUT_SCHEMA, &mut |member, deser| {
   94    101   
            match member.member_index() {
   95    102   
                Some(0) => {
   96    103   
                    builder.body = Some({
   97    104   
                        let _ = member;
   98    105   
                        ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
   99    106   
                    });
  100    107   
                }
  101    108   
                Some(1) => {
  102    109   
                    builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
  103    110   
                }
         111  +
                Some(2) => {
         112  +
                    builder._request_id = Some(deser.read_string(member)?);
         113  +
                }
         114  +
                _ => {}
         115  +
            }
         116  +
            Ok(())
         117  +
        })?;
         118  +
        Ok(builder.build())
         119  +
    }
         120  +
}
         121  +
impl GetObjectTorrentOutput {
         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-amzn-requestid") {
         137  +
            builder._request_id = Some(val.to_string());
         138  +
        }
         139  +
        #[allow(
         140  +
            unused_variables,
         141  +
            unreachable_code,
         142  +
            clippy::single_match,
         143  +
            clippy::match_single_binding,
         144  +
            clippy::diverging_sub_expression
         145  +
        )]
         146  +
        deserializer.read_struct(&GETOBJECTTORRENTOUTPUT_SCHEMA, &mut |member, deser| {
         147  +
            match member.member_index() {
         148  +
                Some(0) => {
         149  +
                    builder.body = Some({
         150  +
                        let _ = member;
         151  +
                        ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
         152  +
                    });
         153  +
                }
         154  +
                Some(1) => { /* read from headers above */ }
  104    155   
                _ => {}
  105    156   
            }
  106    157   
            Ok(())
  107    158   
        })?;
  108    159   
        Ok(builder.build())
  109    160   
    }
  110    161   
}
  111    162   
impl crate::s3_request_id::RequestIdExt for GetObjectTorrentOutput {
  112    163   
    fn extended_request_id(&self) -> Option<&str> {
  113    164   
        self._extended_request_id.as_deref()

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

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

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

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

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/head_bucket.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 `HeadBucket`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct HeadBucket;
    6      6   
impl HeadBucket {
    7      7   
    /// Creates a new `HeadBucket`
    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::head_bucket::HeadBucketInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::head_bucket::HeadBucketOutput::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::head_bucket::HeadBucketInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::head_bucket::HeadBucketOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::head_bucket::HeadBucketError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -121,125 +183,188 @@
  141    145   
                    .build(),
  142    146   
            );
  143    147   
  144    148   
        ::std::borrow::Cow::Owned(rcb)
  145    149   
    }
  146    150   
}
  147    151   
  148    152   
#[derive(Debug)]
  149    153   
struct HeadBucketResponseDeserializer;
  150    154   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HeadBucketResponseDeserializer {
  151         -
    fn deserialize_nonstreaming(
         155  +
    fn deserialize_nonstreaming_with_config(
  152    156   
        &self,
  153    157   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         158  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  154    159   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  155    160   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  156    161   
        let headers = response.headers();
  157    162   
        let body = response.body().bytes().expect("body loaded");
  158    163   
        #[allow(unused_mut)]
  159    164   
        let mut force_error = false;
  160    165   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  161    166   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  162    167   
            force_error = true;
  163    168   
        }
@@ -280,285 +340,349 @@
  300    305   
            .expect("the config must have a deserializer");
  301    306   
  302    307   
        let parsed = de.deserialize_streaming(&mut http_response);
  303    308   
        let parsed = parsed.unwrap_or_else(|| {
  304    309   
            let http_response = http_response.map(|body| {
  305    310   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  306    311   
                    body.bytes().unwrap(),
  307    312   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  308    313   
                )))
  309    314   
            });
  310         -
            de.deserialize_nonstreaming(&http_response)
         315  +
            // Build a config bag with the protocol for schema-based deserialization
         316  +
            #[allow(unused_mut)]
         317  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         318  +
         319  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  311    320   
        });
  312    321   
        let parsed = parsed.expect_err("should be error response");
  313    322   
        let parsed: &crate::operation::head_bucket::HeadBucketError = parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
  314    323   
        if let crate::operation::head_bucket::HeadBucketError::NotFound(parsed) = parsed {
  315    324   
            ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
  316    325   
        } else {
  317    326   
            panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
  318    327   
        }
  319    328   
    }
  320    329   
}

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

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

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

@@ -41,41 +225,269 @@
   61     61   
    "com.amazonaws.s3.synthetic",
   62     62   
    "HeadBucketOutput",
   63     63   
);
   64     64   
static HEADBUCKETOUTPUT_MEMBER_BUCKET_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static(
   66     66   
        "com.amazonaws.s3.synthetic#HeadBucketOutput$BucketArn",
   67     67   
        "com.amazonaws.s3.synthetic",
   68     68   
        "HeadBucketOutput",
   69     69   
    ),
   70     70   
    ::aws_smithy_schema::ShapeType::String,
   71         -
    "bucket_arn",
          71  +
    "BucketArn",
   72     72   
    0,
   73     73   
)
   74     74   
.with_http_header("x-amz-bucket-arn");
   75     75   
static HEADBUCKETOUTPUT_MEMBER_BUCKET_LOCATION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static(
   77     77   
        "com.amazonaws.s3.synthetic#HeadBucketOutput$BucketLocationType",
   78     78   
        "com.amazonaws.s3.synthetic",
   79     79   
        "HeadBucketOutput",
   80     80   
    ),
   81     81   
    ::aws_smithy_schema::ShapeType::String,
   82         -
    "bucket_location_type",
          82  +
    "BucketLocationType",
   83     83   
    1,
   84     84   
)
   85     85   
.with_http_header("x-amz-bucket-location-type");
   86     86   
static HEADBUCKETOUTPUT_MEMBER_BUCKET_LOCATION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.s3.synthetic#HeadBucketOutput$BucketLocationName",
   89     89   
        "com.amazonaws.s3.synthetic",
   90     90   
        "HeadBucketOutput",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::String,
   93         -
    "bucket_location_name",
          93  +
    "BucketLocationName",
   94     94   
    2,
   95     95   
)
   96     96   
.with_http_header("x-amz-bucket-location-name");
   97     97   
static HEADBUCKETOUTPUT_MEMBER_BUCKET_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.s3.synthetic#HeadBucketOutput$BucketRegion",
  100    100   
        "com.amazonaws.s3.synthetic",
  101    101   
        "HeadBucketOutput",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::String,
  104         -
    "bucket_region",
         104  +
    "BucketRegion",
  105    105   
    3,
  106    106   
)
  107    107   
.with_http_header("x-amz-bucket-region");
  108    108   
static HEADBUCKETOUTPUT_MEMBER_ACCESS_POINT_ALIAS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static(
  110    110   
        "com.amazonaws.s3.synthetic#HeadBucketOutput$AccessPointAlias",
  111    111   
        "com.amazonaws.s3.synthetic",
  112    112   
        "HeadBucketOutput",
  113    113   
    ),
  114    114   
    ::aws_smithy_schema::ShapeType::Boolean,
  115         -
    "access_point_alias",
         115  +
    "AccessPointAlias",
  116    116   
    4,
  117    117   
)
  118    118   
.with_http_header("x-amz-access-point-alias");
         119  +
static HEADBUCKETOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         120  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         121  +
    ::aws_smithy_schema::ShapeType::String,
         122  +
    "request_id",
         123  +
    5,
         124  +
)
         125  +
.with_http_header("x-amzn-requestid");
  119    126   
static HEADBUCKETOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  120    127   
    HEADBUCKETOUTPUT_SCHEMA_ID,
  121    128   
    ::aws_smithy_schema::ShapeType::Structure,
  122    129   
    &[
  123    130   
        &HEADBUCKETOUTPUT_MEMBER_BUCKET_ARN,
  124    131   
        &HEADBUCKETOUTPUT_MEMBER_BUCKET_LOCATION_TYPE,
  125    132   
        &HEADBUCKETOUTPUT_MEMBER_BUCKET_LOCATION_NAME,
  126    133   
        &HEADBUCKETOUTPUT_MEMBER_BUCKET_REGION,
  127    134   
        &HEADBUCKETOUTPUT_MEMBER_ACCESS_POINT_ALIAS,
         135  +
        &HEADBUCKETOUTPUT_MEMBER__REQUEST_ID,
  128    136   
    ],
  129    137   
);
  130    138   
impl HeadBucketOutput {
  131    139   
    /// The schema for this shape.
  132    140   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HEADBUCKETOUTPUT_SCHEMA;
  133    141   
}
  134    142   
impl ::aws_smithy_schema::serde::SerializableStruct for HeadBucketOutput {
  135    143   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  136    144   
    fn serialize_members(
  137    145   
        &self,
  138    146   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  139    147   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  140    148   
        if let Some(ref val) = self.bucket_arn {
  141    149   
            ser.write_string(&HEADBUCKETOUTPUT_MEMBER_BUCKET_ARN, val)?;
  142    150   
        }
  143    151   
        if let Some(ref val) = self.bucket_location_type {
  144    152   
            ser.write_string(&HEADBUCKETOUTPUT_MEMBER_BUCKET_LOCATION_TYPE, val.as_str())?;
  145    153   
        }
  146    154   
        if let Some(ref val) = self.bucket_location_name {
  147    155   
            ser.write_string(&HEADBUCKETOUTPUT_MEMBER_BUCKET_LOCATION_NAME, val)?;
  148    156   
        }
  149    157   
        if let Some(ref val) = self.bucket_region {
  150    158   
            ser.write_string(&HEADBUCKETOUTPUT_MEMBER_BUCKET_REGION, val)?;
  151    159   
        }
  152    160   
        if let Some(ref val) = self.access_point_alias {
  153    161   
            ser.write_boolean(&HEADBUCKETOUTPUT_MEMBER_ACCESS_POINT_ALIAS, *val)?;
  154    162   
        }
  155    163   
        Ok(())
  156    164   
    }
  157    165   
}
  158    166   
impl HeadBucketOutput {
  159    167   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  160         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  161         -
        deserializer: &mut D,
         168  +
    pub fn deserialize(
         169  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  162    170   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  163    171   
        #[allow(unused_variables, unused_mut)]
  164    172   
        let mut builder = Self::builder();
  165    173   
        #[allow(
  166    174   
            unused_variables,
  167    175   
            unreachable_code,
  168    176   
            clippy::single_match,
  169    177   
            clippy::match_single_binding,
  170    178   
            clippy::diverging_sub_expression
  171    179   
        )]
  172         -
        deserializer.read_struct(&HEADBUCKETOUTPUT_SCHEMA, (), |_, member, deser| {
         180  +
        deserializer.read_struct(&HEADBUCKETOUTPUT_SCHEMA, &mut |member, deser| {
  173    181   
            match member.member_index() {
  174    182   
                Some(0) => {
  175    183   
                    builder.bucket_arn = Some(deser.read_string(member)?);
  176    184   
                }
  177    185   
                Some(1) => {
  178    186   
                    builder.bucket_location_type = Some(crate::types::LocationType::from(deser.read_string(member)?.as_str()));
  179    187   
                }
  180    188   
                Some(2) => {
  181    189   
                    builder.bucket_location_name = Some(deser.read_string(member)?);
  182    190   
                }
  183    191   
                Some(3) => {
  184    192   
                    builder.bucket_region = Some(deser.read_string(member)?);
  185    193   
                }
  186    194   
                Some(4) => {
  187    195   
                    builder.access_point_alias = Some(deser.read_boolean(member)?);
  188    196   
                }
         197  +
                Some(5) => {
         198  +
                    builder._request_id = Some(deser.read_string(member)?);
         199  +
                }
  189    200   
                _ => {}
  190    201   
            }
  191    202   
            Ok(())
  192    203   
        })?;
  193    204   
        Ok(builder.build())
  194    205   
    }
  195    206   
}
         207  +
impl HeadBucketOutput {
         208  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         209  +
    /// Header-bound members are read directly from headers, avoiding runtime
         210  +
    /// member iteration overhead. Body members are read via the deserializer.
         211  +
    pub fn deserialize_with_response(
         212  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         213  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         214  +
        _status: u16,
         215  +
        _body: &[u8],
         216  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         217  +
        #[allow(unused_variables, unused_mut)]
         218  +
        let mut builder = Self::builder();
         219  +
        if let Some(val) = headers.get("x-amz-bucket-arn") {
         220  +
            builder.bucket_arn = Some(val.to_string());
         221  +
        }
         222  +
        if let Some(val) = headers.get("x-amz-bucket-location-type") {
         223  +
            builder.bucket_location_type = Some(crate::types::LocationType::from(val));
         224  +
        }
         225  +
        if let Some(val) = headers.get("x-amz-bucket-location-name") {
         226  +
            builder.bucket_location_name = Some(val.to_string());
         227  +
        }
         228  +
        if let Some(val) = headers.get("x-amz-bucket-region") {
         229  +
            builder.bucket_region = Some(val.to_string());
         230  +
        }
         231  +
        if let Some(val) = headers.get("x-amz-access-point-alias") {
         232  +
            builder.access_point_alias = val.parse::<bool>().ok();
         233  +
        }
         234  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         235  +
            builder._request_id = Some(val.to_string());
         236  +
        }
         237  +
        Ok(builder.build())
         238  +
    }
         239  +
}
  196    240   
impl crate::s3_request_id::RequestIdExt for HeadBucketOutput {
  197    241   
    fn extended_request_id(&self) -> Option<&str> {
  198    242   
        self._extended_request_id.as_deref()
  199    243   
    }
  200    244   
}
  201    245   
impl ::aws_types::request_id::RequestId for HeadBucketOutput {
  202    246   
    fn request_id(&self) -> Option<&str> {
  203    247   
        self._request_id.as_deref()
  204    248   
    }
  205    249   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/head_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 `HeadObject`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct HeadObject;
    6      6   
impl HeadObject {
    7      7   
    /// Creates a new `HeadObject`
    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::head_object::HeadObjectInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::head_object::HeadObjectOutput::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::head_object::HeadObjectInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::head_object::HeadObjectOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::head_object::HeadObjectError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -123,127 +185,190 @@
  143    147   
                    .build(),
  144    148   
            );
  145    149   
  146    150   
        ::std::borrow::Cow::Owned(rcb)
  147    151   
    }
  148    152   
}
  149    153   
  150    154   
#[derive(Debug)]
  151    155   
struct HeadObjectResponseDeserializer;
  152    156   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HeadObjectResponseDeserializer {
  153         -
    fn deserialize_nonstreaming(
         157  +
    fn deserialize_nonstreaming_with_config(
  154    158   
        &self,
  155    159   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         160  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  156    161   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  157    162   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  158    163   
        let headers = response.headers();
  159    164   
        let body = response.body().bytes().expect("body loaded");
  160    165   
        #[allow(unused_mut)]
  161    166   
        let mut force_error = false;
  162    167   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  163    168   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  164    169   
            force_error = true;
  165    170   
        }
@@ -382,387 +442,451 @@
  402    407   
            .expect("the config must have a deserializer");
  403    408   
  404    409   
        let parsed = de.deserialize_streaming(&mut http_response);
  405    410   
        let parsed = parsed.unwrap_or_else(|| {
  406    411   
            let http_response = http_response.map(|body| {
  407    412   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  408    413   
                    body.bytes().unwrap(),
  409    414   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  410    415   
                )))
  411    416   
            });
  412         -
            de.deserialize_nonstreaming(&http_response)
         417  +
            // Build a config bag with the protocol for schema-based deserialization
         418  +
            #[allow(unused_mut)]
         419  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         420  +
         421  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  413    422   
        });
  414    423   
        let parsed = parsed.expect_err("should be error response");
  415    424   
        let parsed: &crate::operation::head_object::HeadObjectError = parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
  416    425   
        if let crate::operation::head_object::HeadObjectError::NotFound(parsed) = parsed {
  417    426   
            ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
  418    427   
        } else {
  419    428   
            panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
  420    429   
        }
  421    430   
    }
  422    431   
}

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

@@ -250,250 +560,562 @@
  270    270   
    "com.amazonaws.s3.synthetic",
  271    271   
    "HeadObjectInput",
  272    272   
);
  273    273   
static HEADOBJECTINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  274    274   
    ::aws_smithy_schema::ShapeId::from_static(
  275    275   
        "com.amazonaws.s3.synthetic#HeadObjectInput$Bucket",
  276    276   
        "com.amazonaws.s3.synthetic",
  277    277   
        "HeadObjectInput",
  278    278   
    ),
  279    279   
    ::aws_smithy_schema::ShapeType::String,
  280         -
    "bucket",
         280  +
    "Bucket",
  281    281   
    0,
  282    282   
)
  283    283   
.with_http_label();
  284    284   
static HEADOBJECTINPUT_MEMBER_IF_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  285    285   
    ::aws_smithy_schema::ShapeId::from_static(
  286    286   
        "com.amazonaws.s3.synthetic#HeadObjectInput$IfMatch",
  287    287   
        "com.amazonaws.s3.synthetic",
  288    288   
        "HeadObjectInput",
  289    289   
    ),
  290    290   
    ::aws_smithy_schema::ShapeType::String,
  291         -
    "if_match",
         291  +
    "IfMatch",
  292    292   
    1,
  293    293   
)
  294    294   
.with_http_header("If-Match");
  295    295   
static HEADOBJECTINPUT_MEMBER_IF_MODIFIED_SINCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  296    296   
    ::aws_smithy_schema::ShapeId::from_static(
  297    297   
        "com.amazonaws.s3.synthetic#HeadObjectInput$IfModifiedSince",
  298    298   
        "com.amazonaws.s3.synthetic",
  299    299   
        "HeadObjectInput",
  300    300   
    ),
  301    301   
    ::aws_smithy_schema::ShapeType::Timestamp,
  302         -
    "if_modified_since",
         302  +
    "IfModifiedSince",
  303    303   
    2,
  304    304   
)
  305    305   
.with_http_header("If-Modified-Since");
  306    306   
static HEADOBJECTINPUT_MEMBER_IF_NONE_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  307    307   
    ::aws_smithy_schema::ShapeId::from_static(
  308    308   
        "com.amazonaws.s3.synthetic#HeadObjectInput$IfNoneMatch",
  309    309   
        "com.amazonaws.s3.synthetic",
  310    310   
        "HeadObjectInput",
  311    311   
    ),
  312    312   
    ::aws_smithy_schema::ShapeType::String,
  313         -
    "if_none_match",
         313  +
    "IfNoneMatch",
  314    314   
    3,
  315    315   
)
  316    316   
.with_http_header("If-None-Match");
  317    317   
static HEADOBJECTINPUT_MEMBER_IF_UNMODIFIED_SINCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  318    318   
    ::aws_smithy_schema::ShapeId::from_static(
  319    319   
        "com.amazonaws.s3.synthetic#HeadObjectInput$IfUnmodifiedSince",
  320    320   
        "com.amazonaws.s3.synthetic",
  321    321   
        "HeadObjectInput",
  322    322   
    ),
  323    323   
    ::aws_smithy_schema::ShapeType::Timestamp,
  324         -
    "if_unmodified_since",
         324  +
    "IfUnmodifiedSince",
  325    325   
    4,
  326    326   
)
  327    327   
.with_http_header("If-Unmodified-Since");
  328    328   
static HEADOBJECTINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  329    329   
    ::aws_smithy_schema::ShapeId::from_static(
  330    330   
        "com.amazonaws.s3.synthetic#HeadObjectInput$Key",
  331    331   
        "com.amazonaws.s3.synthetic",
  332    332   
        "HeadObjectInput",
  333    333   
    ),
  334    334   
    ::aws_smithy_schema::ShapeType::String,
  335         -
    "key",
         335  +
    "Key",
  336    336   
    5,
  337    337   
)
  338    338   
.with_http_label();
  339    339   
static HEADOBJECTINPUT_MEMBER_RANGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  340    340   
    ::aws_smithy_schema::ShapeId::from_static(
  341    341   
        "com.amazonaws.s3.synthetic#HeadObjectInput$Range",
  342    342   
        "com.amazonaws.s3.synthetic",
  343    343   
        "HeadObjectInput",
  344    344   
    ),
  345    345   
    ::aws_smithy_schema::ShapeType::String,
  346         -
    "range",
         346  +
    "Range",
  347    347   
    6,
  348    348   
)
  349    349   
.with_http_header("Range");
  350    350   
static HEADOBJECTINPUT_MEMBER_RESPONSE_CACHE_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  351    351   
    ::aws_smithy_schema::ShapeId::from_static(
  352    352   
        "com.amazonaws.s3.synthetic#HeadObjectInput$ResponseCacheControl",
  353    353   
        "com.amazonaws.s3.synthetic",
  354    354   
        "HeadObjectInput",
  355    355   
    ),
  356    356   
    ::aws_smithy_schema::ShapeType::String,
  357         -
    "response_cache_control",
         357  +
    "ResponseCacheControl",
  358    358   
    7,
  359    359   
)
  360    360   
.with_http_query("response-cache-control");
  361    361   
static HEADOBJECTINPUT_MEMBER_RESPONSE_CONTENT_DISPOSITION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  362    362   
    ::aws_smithy_schema::ShapeId::from_static(
  363    363   
        "com.amazonaws.s3.synthetic#HeadObjectInput$ResponseContentDisposition",
  364    364   
        "com.amazonaws.s3.synthetic",
  365    365   
        "HeadObjectInput",
  366    366   
    ),
  367    367   
    ::aws_smithy_schema::ShapeType::String,
  368         -
    "response_content_disposition",
         368  +
    "ResponseContentDisposition",
  369    369   
    8,
  370    370   
)
  371    371   
.with_http_query("response-content-disposition");
  372    372   
static HEADOBJECTINPUT_MEMBER_RESPONSE_CONTENT_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  373    373   
    ::aws_smithy_schema::ShapeId::from_static(
  374    374   
        "com.amazonaws.s3.synthetic#HeadObjectInput$ResponseContentEncoding",
  375    375   
        "com.amazonaws.s3.synthetic",
  376    376   
        "HeadObjectInput",
  377    377   
    ),
  378    378   
    ::aws_smithy_schema::ShapeType::String,
  379         -
    "response_content_encoding",
         379  +
    "ResponseContentEncoding",
  380    380   
    9,
  381    381   
)
  382    382   
.with_http_query("response-content-encoding");
  383    383   
static HEADOBJECTINPUT_MEMBER_RESPONSE_CONTENT_LANGUAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  384    384   
    ::aws_smithy_schema::ShapeId::from_static(
  385    385   
        "com.amazonaws.s3.synthetic#HeadObjectInput$ResponseContentLanguage",
  386    386   
        "com.amazonaws.s3.synthetic",
  387    387   
        "HeadObjectInput",
  388    388   
    ),
  389    389   
    ::aws_smithy_schema::ShapeType::String,
  390         -
    "response_content_language",
         390  +
    "ResponseContentLanguage",
  391    391   
    10,
  392    392   
)
  393    393   
.with_http_query("response-content-language");
  394    394   
static HEADOBJECTINPUT_MEMBER_RESPONSE_CONTENT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  395    395   
    ::aws_smithy_schema::ShapeId::from_static(
  396    396   
        "com.amazonaws.s3.synthetic#HeadObjectInput$ResponseContentType",
  397    397   
        "com.amazonaws.s3.synthetic",
  398    398   
        "HeadObjectInput",
  399    399   
    ),
  400    400   
    ::aws_smithy_schema::ShapeType::String,
  401         -
    "response_content_type",
         401  +
    "ResponseContentType",
  402    402   
    11,
  403    403   
)
  404    404   
.with_http_query("response-content-type");
  405    405   
static HEADOBJECTINPUT_MEMBER_RESPONSE_EXPIRES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  406    406   
    ::aws_smithy_schema::ShapeId::from_static(
  407    407   
        "com.amazonaws.s3.synthetic#HeadObjectInput$ResponseExpires",
  408    408   
        "com.amazonaws.s3.synthetic",
  409    409   
        "HeadObjectInput",
  410    410   
    ),
  411    411   
    ::aws_smithy_schema::ShapeType::Timestamp,
  412         -
    "response_expires",
         412  +
    "ResponseExpires",
  413    413   
    12,
  414    414   
)
  415         -
.with_http_query("response-expires");
         415  +
.with_http_query("response-expires")
         416  +
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::HttpDate);
  416    417   
static HEADOBJECTINPUT_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  417    418   
    ::aws_smithy_schema::ShapeId::from_static(
  418    419   
        "com.amazonaws.s3.synthetic#HeadObjectInput$VersionId",
  419    420   
        "com.amazonaws.s3.synthetic",
  420    421   
        "HeadObjectInput",
  421    422   
    ),
  422    423   
    ::aws_smithy_schema::ShapeType::String,
  423         -
    "version_id",
         424  +
    "VersionId",
  424    425   
    13,
  425    426   
)
  426    427   
.with_http_query("versionId");
  427    428   
static HEADOBJECTINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  428    429   
    ::aws_smithy_schema::ShapeId::from_static(
  429    430   
        "com.amazonaws.s3.synthetic#HeadObjectInput$SSECustomerAlgorithm",
  430    431   
        "com.amazonaws.s3.synthetic",
  431    432   
        "HeadObjectInput",
  432    433   
    ),
  433    434   
    ::aws_smithy_schema::ShapeType::String,
  434         -
    "sse_customer_algorithm",
         435  +
    "SSECustomerAlgorithm",
  435    436   
    14,
  436    437   
)
  437    438   
.with_http_header("x-amz-server-side-encryption-customer-algorithm");
  438    439   
static HEADOBJECTINPUT_MEMBER_SSE_CUSTOMER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  439    440   
    ::aws_smithy_schema::ShapeId::from_static(
  440    441   
        "com.amazonaws.s3.synthetic#HeadObjectInput$SSECustomerKey",
  441    442   
        "com.amazonaws.s3.synthetic",
  442    443   
        "HeadObjectInput",
  443    444   
    ),
  444    445   
    ::aws_smithy_schema::ShapeType::String,
  445         -
    "sse_customer_key",
         446  +
    "SSECustomerKey",
  446    447   
    15,
  447    448   
)
  448    449   
.with_http_header("x-amz-server-side-encryption-customer-key");
  449    450   
static HEADOBJECTINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  450    451   
    ::aws_smithy_schema::ShapeId::from_static(
  451    452   
        "com.amazonaws.s3.synthetic#HeadObjectInput$SSECustomerKeyMD5",
  452    453   
        "com.amazonaws.s3.synthetic",
  453    454   
        "HeadObjectInput",
  454    455   
    ),
  455    456   
    ::aws_smithy_schema::ShapeType::String,
  456         -
    "sse_customer_key_md5",
         457  +
    "SSECustomerKeyMD5",
  457    458   
    16,
  458    459   
)
  459    460   
.with_http_header("x-amz-server-side-encryption-customer-key-MD5");
  460    461   
static HEADOBJECTINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  461    462   
    ::aws_smithy_schema::ShapeId::from_static(
  462    463   
        "com.amazonaws.s3.synthetic#HeadObjectInput$RequestPayer",
  463    464   
        "com.amazonaws.s3.synthetic",
  464    465   
        "HeadObjectInput",
  465    466   
    ),
  466    467   
    ::aws_smithy_schema::ShapeType::String,
  467         -
    "request_payer",
         468  +
    "RequestPayer",
  468    469   
    17,
  469    470   
)
  470    471   
.with_http_header("x-amz-request-payer");
  471    472   
static HEADOBJECTINPUT_MEMBER_PART_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  472    473   
    ::aws_smithy_schema::ShapeId::from_static(
  473    474   
        "com.amazonaws.s3.synthetic#HeadObjectInput$PartNumber",
  474    475   
        "com.amazonaws.s3.synthetic",
  475    476   
        "HeadObjectInput",
  476    477   
    ),
  477    478   
    ::aws_smithy_schema::ShapeType::Integer,
  478         -
    "part_number",
         479  +
    "PartNumber",
  479    480   
    18,
  480    481   
)
  481    482   
.with_http_query("partNumber");
  482    483   
static HEADOBJECTINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  483    484   
    ::aws_smithy_schema::ShapeId::from_static(
  484    485   
        "com.amazonaws.s3.synthetic#HeadObjectInput$ExpectedBucketOwner",
  485    486   
        "com.amazonaws.s3.synthetic",
  486    487   
        "HeadObjectInput",
  487    488   
    ),
  488    489   
    ::aws_smithy_schema::ShapeType::String,
  489         -
    "expected_bucket_owner",
         490  +
    "ExpectedBucketOwner",
  490    491   
    19,
  491    492   
)
  492    493   
.with_http_header("x-amz-expected-bucket-owner");
  493    494   
static HEADOBJECTINPUT_MEMBER_CHECKSUM_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  494    495   
    ::aws_smithy_schema::ShapeId::from_static(
  495    496   
        "com.amazonaws.s3.synthetic#HeadObjectInput$ChecksumMode",
  496    497   
        "com.amazonaws.s3.synthetic",
  497    498   
        "HeadObjectInput",
  498    499   
    ),
  499    500   
    ::aws_smithy_schema::ShapeType::String,
  500         -
    "checksum_mode",
         501  +
    "ChecksumMode",
  501    502   
    20,
  502    503   
)
  503    504   
.with_http_header("x-amz-checksum-mode");
  504    505   
static HEADOBJECTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  505    506   
    HEADOBJECTINPUT_SCHEMA_ID,
  506    507   
    ::aws_smithy_schema::ShapeType::Structure,
  507    508   
    &[
  508    509   
        &HEADOBJECTINPUT_MEMBER_BUCKET,
  509    510   
        &HEADOBJECTINPUT_MEMBER_IF_MATCH,
  510    511   
        &HEADOBJECTINPUT_MEMBER_IF_MODIFIED_SINCE,
  511    512   
        &HEADOBJECTINPUT_MEMBER_IF_NONE_MATCH,
  512    513   
        &HEADOBJECTINPUT_MEMBER_IF_UNMODIFIED_SINCE,
  513    514   
        &HEADOBJECTINPUT_MEMBER_KEY,
  514    515   
        &HEADOBJECTINPUT_MEMBER_RANGE,
  515    516   
        &HEADOBJECTINPUT_MEMBER_RESPONSE_CACHE_CONTROL,
  516    517   
        &HEADOBJECTINPUT_MEMBER_RESPONSE_CONTENT_DISPOSITION,
  517    518   
        &HEADOBJECTINPUT_MEMBER_RESPONSE_CONTENT_ENCODING,
  518    519   
        &HEADOBJECTINPUT_MEMBER_RESPONSE_CONTENT_LANGUAGE,
  519    520   
        &HEADOBJECTINPUT_MEMBER_RESPONSE_CONTENT_TYPE,
  520    521   
        &HEADOBJECTINPUT_MEMBER_RESPONSE_EXPIRES,
  521    522   
        &HEADOBJECTINPUT_MEMBER_VERSION_ID,
  522    523   
        &HEADOBJECTINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
  523    524   
        &HEADOBJECTINPUT_MEMBER_SSE_CUSTOMER_KEY,
  524    525   
        &HEADOBJECTINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
  525    526   
        &HEADOBJECTINPUT_MEMBER_REQUEST_PAYER,
  526    527   
        &HEADOBJECTINPUT_MEMBER_PART_NUMBER,
  527    528   
        &HEADOBJECTINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
  528    529   
        &HEADOBJECTINPUT_MEMBER_CHECKSUM_MODE,
  529    530   
    ],
  530         -
);
         531  +
)
         532  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("HEAD", "/{Key+}", None));
  531    533   
impl HeadObjectInput {
  532    534   
    /// The schema for this shape.
  533    535   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HEADOBJECTINPUT_SCHEMA;
  534    536   
}
  535    537   
impl ::aws_smithy_schema::serde::SerializableStruct for HeadObjectInput {
  536    538   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  537    539   
    fn serialize_members(
  538    540   
        &self,
  539    541   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  540    542   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
@@ -579,581 +651,653 @@
  599    601   
            ser.write_string(&HEADOBJECTINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
  600    602   
        }
  601    603   
        if let Some(ref val) = self.checksum_mode {
  602    604   
            ser.write_string(&HEADOBJECTINPUT_MEMBER_CHECKSUM_MODE, val.as_str())?;
  603    605   
        }
  604    606   
        Ok(())
  605    607   
    }
  606    608   
}
  607    609   
impl HeadObjectInput {
  608    610   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  609         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  610         -
        deserializer: &mut D,
         611  +
    pub fn deserialize(
         612  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  611    613   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  612    614   
        #[allow(unused_variables, unused_mut)]
  613    615   
        let mut builder = Self::builder();
  614    616   
        #[allow(
  615    617   
            unused_variables,
  616    618   
            unreachable_code,
  617    619   
            clippy::single_match,
  618    620   
            clippy::match_single_binding,
  619    621   
            clippy::diverging_sub_expression
  620    622   
        )]
  621         -
        deserializer.read_struct(&HEADOBJECTINPUT_SCHEMA, (), |_, member, deser| {
         623  +
        deserializer.read_struct(&HEADOBJECTINPUT_SCHEMA, &mut |member, deser| {
  622    624   
            match member.member_index() {
  623    625   
                Some(0) => {
  624    626   
                    builder.bucket = Some(deser.read_string(member)?);
  625    627   
                }
  626    628   
                Some(1) => {
  627    629   
                    builder.if_match = Some(deser.read_string(member)?);
  628    630   
                }
  629    631   
                Some(2) => {
  630    632   
                    builder.if_modified_since = Some(deser.read_timestamp(member)?);
  631    633   
                }
@@ -660,662 +719,827 @@
  680    682   
                Some(19) => {
  681    683   
                    builder.expected_bucket_owner = Some(deser.read_string(member)?);
  682    684   
                }
  683    685   
                Some(20) => {
  684    686   
                    builder.checksum_mode = Some(crate::types::ChecksumMode::from(deser.read_string(member)?.as_str()));
  685    687   
                }
  686    688   
                _ => {}
  687    689   
            }
  688    690   
            Ok(())
  689    691   
        })?;
         692  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         693  +
        builder.key = builder.key.or(Some(String::new()));
         694  +
        builder
         695  +
            .build()
         696  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         697  +
    }
         698  +
}
         699  +
impl HeadObjectInput {
         700  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         701  +
    /// Header-bound members are read directly from headers, avoiding runtime
         702  +
    /// member iteration overhead. Body members are read via the deserializer.
         703  +
    pub fn deserialize_with_response(
         704  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         705  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         706  +
        _status: u16,
         707  +
        _body: &[u8],
         708  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         709  +
        #[allow(unused_variables, unused_mut)]
         710  +
        let mut builder = Self::builder();
         711  +
        if let Some(val) = headers.get("If-Match") {
         712  +
            builder.if_match = Some(val.to_string());
         713  +
        }
         714  +
        if let Some(val) = headers.get("If-Modified-Since") {
         715  +
            builder.if_modified_since = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
         716  +
        }
         717  +
        if let Some(val) = headers.get("If-None-Match") {
         718  +
            builder.if_none_match = Some(val.to_string());
         719  +
        }
         720  +
        if let Some(val) = headers.get("If-Unmodified-Since") {
         721  +
            builder.if_unmodified_since = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
         722  +
        }
         723  +
        if let Some(val) = headers.get("Range") {
         724  +
            builder.range = Some(val.to_string());
         725  +
        }
         726  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
         727  +
            builder.sse_customer_algorithm = Some(val.to_string());
         728  +
        }
         729  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key") {
         730  +
            builder.sse_customer_key = Some(val.to_string());
         731  +
        }
         732  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
         733  +
            builder.sse_customer_key_md5 = Some(val.to_string());
         734  +
        }
         735  +
        if let Some(val) = headers.get("x-amz-request-payer") {
         736  +
            builder.request_payer = Some(crate::types::RequestPayer::from(val));
         737  +
        }
         738  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         739  +
            builder.expected_bucket_owner = Some(val.to_string());
         740  +
        }
         741  +
        if let Some(val) = headers.get("x-amz-checksum-mode") {
         742  +
            builder.checksum_mode = Some(crate::types::ChecksumMode::from(val));
         743  +
        }
         744  +
        #[allow(
         745  +
            unused_variables,
         746  +
            unreachable_code,
         747  +
            clippy::single_match,
         748  +
            clippy::match_single_binding,
         749  +
            clippy::diverging_sub_expression
         750  +
        )]
         751  +
        deserializer.read_struct(&HEADOBJECTINPUT_SCHEMA, &mut |member, deser| {
         752  +
            match member.member_index() {
         753  +
                Some(0) => {
         754  +
                    builder.bucket = Some(deser.read_string(member)?);
         755  +
                }
         756  +
                Some(1) => { /* read from headers above */ }
         757  +
                Some(2) => { /* read from headers above */ }
         758  +
                Some(3) => { /* read from headers above */ }
         759  +
                Some(4) => { /* read from headers above */ }
         760  +
                Some(5) => {
         761  +
                    builder.key = Some(deser.read_string(member)?);
         762  +
                }
         763  +
                Some(6) => { /* read from headers above */ }
         764  +
                Some(7) => {
         765  +
                    builder.response_cache_control = Some(deser.read_string(member)?);
         766  +
                }
         767  +
                Some(8) => {
         768  +
                    builder.response_content_disposition = Some(deser.read_string(member)?);
         769  +
                }
         770  +
                Some(9) => {
         771  +
                    builder.response_content_encoding = Some(deser.read_string(member)?);
         772  +
                }
         773  +
                Some(10) => {
         774  +
                    builder.response_content_language = Some(deser.read_string(member)?);
         775  +
                }
         776  +
                Some(11) => {
         777  +
                    builder.response_content_type = Some(deser.read_string(member)?);
         778  +
                }
         779  +
                Some(12) => {
         780  +
                    builder.response_expires = Some(deser.read_timestamp(member)?);
         781  +
                }
         782  +
                Some(13) => {
         783  +
                    builder.version_id = Some(deser.read_string(member)?);
         784  +
                }
         785  +
                Some(14) => { /* read from headers above */ }
         786  +
                Some(15) => { /* read from headers above */ }
         787  +
                Some(16) => { /* read from headers above */ }
         788  +
                Some(17) => { /* read from headers above */ }
         789  +
                Some(18) => {
         790  +
                    builder.part_number = Some(deser.read_integer(member)?);
         791  +
                }
         792  +
                Some(19) => { /* read from headers above */ }
         793  +
                Some(20) => { /* read from headers above */ }
         794  +
                _ => {}
         795  +
            }
         796  +
            Ok(())
         797  +
        })?;
  690    798   
        builder
  691    799   
            .build()
  692    800   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  693    801   
    }
  694    802   
}
  695    803   
impl HeadObjectInput {
  696    804   
    /// Creates a new builder-style object to manufacture [`HeadObjectInput`](crate::operation::head_object::HeadObjectInput).
  697    805   
    pub fn builder() -> crate::operation::head_object::builders::HeadObjectInputBuilder {
  698    806   
        crate::operation::head_object::builders::HeadObjectInputBuilder::default()
  699    807   
    }

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

@@ -378,378 +902,911 @@
  398    398   
    "com.amazonaws.s3.synthetic",
  399    399   
    "HeadObjectOutput",
  400    400   
);
  401    401   
static HEADOBJECTOUTPUT_MEMBER_DELETE_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  402    402   
    ::aws_smithy_schema::ShapeId::from_static(
  403    403   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$DeleteMarker",
  404    404   
        "com.amazonaws.s3.synthetic",
  405    405   
        "HeadObjectOutput",
  406    406   
    ),
  407    407   
    ::aws_smithy_schema::ShapeType::Boolean,
  408         -
    "delete_marker",
         408  +
    "DeleteMarker",
  409    409   
    0,
  410    410   
)
  411    411   
.with_http_header("x-amz-delete-marker");
  412    412   
static HEADOBJECTOUTPUT_MEMBER_ACCEPT_RANGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  413    413   
    ::aws_smithy_schema::ShapeId::from_static(
  414    414   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$AcceptRanges",
  415    415   
        "com.amazonaws.s3.synthetic",
  416    416   
        "HeadObjectOutput",
  417    417   
    ),
  418    418   
    ::aws_smithy_schema::ShapeType::String,
  419         -
    "accept_ranges",
         419  +
    "AcceptRanges",
  420    420   
    1,
  421    421   
)
  422    422   
.with_http_header("accept-ranges");
  423    423   
static HEADOBJECTOUTPUT_MEMBER_EXPIRATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  424    424   
    ::aws_smithy_schema::ShapeId::from_static(
  425    425   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$Expiration",
  426    426   
        "com.amazonaws.s3.synthetic",
  427    427   
        "HeadObjectOutput",
  428    428   
    ),
  429    429   
    ::aws_smithy_schema::ShapeType::String,
  430         -
    "expiration",
         430  +
    "Expiration",
  431    431   
    2,
  432    432   
)
  433    433   
.with_http_header("x-amz-expiration");
  434    434   
static HEADOBJECTOUTPUT_MEMBER_RESTORE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  435    435   
    ::aws_smithy_schema::ShapeId::from_static(
  436    436   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$Restore",
  437    437   
        "com.amazonaws.s3.synthetic",
  438    438   
        "HeadObjectOutput",
  439    439   
    ),
  440    440   
    ::aws_smithy_schema::ShapeType::String,
  441         -
    "restore",
         441  +
    "Restore",
  442    442   
    3,
  443    443   
)
  444    444   
.with_http_header("x-amz-restore");
  445    445   
static HEADOBJECTOUTPUT_MEMBER_ARCHIVE_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  446    446   
    ::aws_smithy_schema::ShapeId::from_static(
  447    447   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ArchiveStatus",
  448    448   
        "com.amazonaws.s3.synthetic",
  449    449   
        "HeadObjectOutput",
  450    450   
    ),
  451    451   
    ::aws_smithy_schema::ShapeType::String,
  452         -
    "archive_status",
         452  +
    "ArchiveStatus",
  453    453   
    4,
  454    454   
)
  455    455   
.with_http_header("x-amz-archive-status");
  456    456   
static HEADOBJECTOUTPUT_MEMBER_LAST_MODIFIED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  457    457   
    ::aws_smithy_schema::ShapeId::from_static(
  458    458   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$LastModified",
  459    459   
        "com.amazonaws.s3.synthetic",
  460    460   
        "HeadObjectOutput",
  461    461   
    ),
  462    462   
    ::aws_smithy_schema::ShapeType::Timestamp,
  463         -
    "last_modified",
         463  +
    "LastModified",
  464    464   
    5,
  465    465   
)
  466    466   
.with_http_header("Last-Modified");
  467    467   
static HEADOBJECTOUTPUT_MEMBER_CONTENT_LENGTH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  468    468   
    ::aws_smithy_schema::ShapeId::from_static(
  469    469   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ContentLength",
  470    470   
        "com.amazonaws.s3.synthetic",
  471    471   
        "HeadObjectOutput",
  472    472   
    ),
  473    473   
    ::aws_smithy_schema::ShapeType::Long,
  474         -
    "content_length",
         474  +
    "ContentLength",
  475    475   
    6,
  476    476   
)
  477    477   
.with_http_header("Content-Length");
  478    478   
static HEADOBJECTOUTPUT_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  479    479   
    ::aws_smithy_schema::ShapeId::from_static(
  480    480   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ChecksumCRC32",
  481    481   
        "com.amazonaws.s3.synthetic",
  482    482   
        "HeadObjectOutput",
  483    483   
    ),
  484    484   
    ::aws_smithy_schema::ShapeType::String,
  485         -
    "checksum_crc32",
         485  +
    "ChecksumCRC32",
  486    486   
    7,
  487    487   
)
  488    488   
.with_http_header("x-amz-checksum-crc32");
  489    489   
static HEADOBJECTOUTPUT_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  490    490   
    ::aws_smithy_schema::ShapeId::from_static(
  491    491   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ChecksumCRC32C",
  492    492   
        "com.amazonaws.s3.synthetic",
  493    493   
        "HeadObjectOutput",
  494    494   
    ),
  495    495   
    ::aws_smithy_schema::ShapeType::String,
  496         -
    "checksum_crc32_c",
         496  +
    "ChecksumCRC32C",
  497    497   
    8,
  498    498   
)
  499    499   
.with_http_header("x-amz-checksum-crc32c");
  500    500   
static HEADOBJECTOUTPUT_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  501    501   
    ::aws_smithy_schema::ShapeId::from_static(
  502    502   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ChecksumCRC64NVME",
  503    503   
        "com.amazonaws.s3.synthetic",
  504    504   
        "HeadObjectOutput",
  505    505   
    ),
  506    506   
    ::aws_smithy_schema::ShapeType::String,
  507         -
    "checksum_crc64_nvme",
         507  +
    "ChecksumCRC64NVME",
  508    508   
    9,
  509    509   
)
  510    510   
.with_http_header("x-amz-checksum-crc64nvme");
  511    511   
static HEADOBJECTOUTPUT_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  512    512   
    ::aws_smithy_schema::ShapeId::from_static(
  513    513   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ChecksumSHA1",
  514    514   
        "com.amazonaws.s3.synthetic",
  515    515   
        "HeadObjectOutput",
  516    516   
    ),
  517    517   
    ::aws_smithy_schema::ShapeType::String,
  518         -
    "checksum_sha1",
         518  +
    "ChecksumSHA1",
  519    519   
    10,
  520    520   
)
  521    521   
.with_http_header("x-amz-checksum-sha1");
  522    522   
static HEADOBJECTOUTPUT_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  523    523   
    ::aws_smithy_schema::ShapeId::from_static(
  524    524   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ChecksumSHA256",
  525    525   
        "com.amazonaws.s3.synthetic",
  526    526   
        "HeadObjectOutput",
  527    527   
    ),
  528    528   
    ::aws_smithy_schema::ShapeType::String,
  529         -
    "checksum_sha256",
         529  +
    "ChecksumSHA256",
  530    530   
    11,
  531    531   
)
  532    532   
.with_http_header("x-amz-checksum-sha256");
  533    533   
static HEADOBJECTOUTPUT_MEMBER_CHECKSUM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  534    534   
    ::aws_smithy_schema::ShapeId::from_static(
  535    535   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ChecksumType",
  536    536   
        "com.amazonaws.s3.synthetic",
  537    537   
        "HeadObjectOutput",
  538    538   
    ),
  539    539   
    ::aws_smithy_schema::ShapeType::String,
  540         -
    "checksum_type",
         540  +
    "ChecksumType",
  541    541   
    12,
  542    542   
)
  543    543   
.with_http_header("x-amz-checksum-type");
  544    544   
static HEADOBJECTOUTPUT_MEMBER_E_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  545    545   
    ::aws_smithy_schema::ShapeId::from_static(
  546    546   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ETag",
  547    547   
        "com.amazonaws.s3.synthetic",
  548    548   
        "HeadObjectOutput",
  549    549   
    ),
  550    550   
    ::aws_smithy_schema::ShapeType::String,
  551         -
    "e_tag",
         551  +
    "ETag",
  552    552   
    13,
  553    553   
)
  554    554   
.with_http_header("ETag");
  555    555   
static HEADOBJECTOUTPUT_MEMBER_MISSING_META: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  556    556   
    ::aws_smithy_schema::ShapeId::from_static(
  557    557   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$MissingMeta",
  558    558   
        "com.amazonaws.s3.synthetic",
  559    559   
        "HeadObjectOutput",
  560    560   
    ),
  561    561   
    ::aws_smithy_schema::ShapeType::Integer,
  562         -
    "missing_meta",
         562  +
    "MissingMeta",
  563    563   
    14,
  564    564   
)
  565    565   
.with_http_header("x-amz-missing-meta");
  566    566   
static HEADOBJECTOUTPUT_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  567    567   
    ::aws_smithy_schema::ShapeId::from_static(
  568    568   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$VersionId",
  569    569   
        "com.amazonaws.s3.synthetic",
  570    570   
        "HeadObjectOutput",
  571    571   
    ),
  572    572   
    ::aws_smithy_schema::ShapeType::String,
  573         -
    "version_id",
         573  +
    "VersionId",
  574    574   
    15,
  575    575   
)
  576    576   
.with_http_header("x-amz-version-id");
  577    577   
static HEADOBJECTOUTPUT_MEMBER_CACHE_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  578    578   
    ::aws_smithy_schema::ShapeId::from_static(
  579    579   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$CacheControl",
  580    580   
        "com.amazonaws.s3.synthetic",
  581    581   
        "HeadObjectOutput",
  582    582   
    ),
  583    583   
    ::aws_smithy_schema::ShapeType::String,
  584         -
    "cache_control",
         584  +
    "CacheControl",
  585    585   
    16,
  586    586   
)
  587    587   
.with_http_header("Cache-Control");
  588    588   
static HEADOBJECTOUTPUT_MEMBER_CONTENT_DISPOSITION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  589    589   
    ::aws_smithy_schema::ShapeId::from_static(
  590    590   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ContentDisposition",
  591    591   
        "com.amazonaws.s3.synthetic",
  592    592   
        "HeadObjectOutput",
  593    593   
    ),
  594    594   
    ::aws_smithy_schema::ShapeType::String,
  595         -
    "content_disposition",
         595  +
    "ContentDisposition",
  596    596   
    17,
  597    597   
)
  598    598   
.with_http_header("Content-Disposition");
  599    599   
static HEADOBJECTOUTPUT_MEMBER_CONTENT_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  600    600   
    ::aws_smithy_schema::ShapeId::from_static(
  601    601   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ContentEncoding",
  602    602   
        "com.amazonaws.s3.synthetic",
  603    603   
        "HeadObjectOutput",
  604    604   
    ),
  605    605   
    ::aws_smithy_schema::ShapeType::String,
  606         -
    "content_encoding",
         606  +
    "ContentEncoding",
  607    607   
    18,
  608    608   
)
  609    609   
.with_http_header("Content-Encoding");
  610    610   
static HEADOBJECTOUTPUT_MEMBER_CONTENT_LANGUAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  611    611   
    ::aws_smithy_schema::ShapeId::from_static(
  612    612   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ContentLanguage",
  613    613   
        "com.amazonaws.s3.synthetic",
  614    614   
        "HeadObjectOutput",
  615    615   
    ),
  616    616   
    ::aws_smithy_schema::ShapeType::String,
  617         -
    "content_language",
         617  +
    "ContentLanguage",
  618    618   
    19,
  619    619   
)
  620    620   
.with_http_header("Content-Language");
  621    621   
static HEADOBJECTOUTPUT_MEMBER_CONTENT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  622    622   
    ::aws_smithy_schema::ShapeId::from_static(
  623    623   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ContentType",
  624    624   
        "com.amazonaws.s3.synthetic",
  625    625   
        "HeadObjectOutput",
  626    626   
    ),
  627    627   
    ::aws_smithy_schema::ShapeType::String,
  628         -
    "content_type",
         628  +
    "ContentType",
  629    629   
    20,
  630    630   
)
  631    631   
.with_http_header("Content-Type");
  632    632   
static HEADOBJECTOUTPUT_MEMBER_CONTENT_RANGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  633    633   
    ::aws_smithy_schema::ShapeId::from_static(
  634    634   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ContentRange",
  635    635   
        "com.amazonaws.s3.synthetic",
  636    636   
        "HeadObjectOutput",
  637    637   
    ),
  638    638   
    ::aws_smithy_schema::ShapeType::String,
  639         -
    "content_range",
         639  +
    "ContentRange",
  640    640   
    21,
  641    641   
)
  642    642   
.with_http_header("Content-Range");
  643    643   
static HEADOBJECTOUTPUT_MEMBER_WEBSITE_REDIRECT_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  644    644   
    ::aws_smithy_schema::ShapeId::from_static(
  645    645   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$WebsiteRedirectLocation",
  646    646   
        "com.amazonaws.s3.synthetic",
  647    647   
        "HeadObjectOutput",
  648    648   
    ),
  649    649   
    ::aws_smithy_schema::ShapeType::String,
  650         -
    "website_redirect_location",
         650  +
    "WebsiteRedirectLocation",
  651    651   
    22,
  652    652   
)
  653    653   
.with_http_header("x-amz-website-redirect-location");
  654    654   
static HEADOBJECTOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  655    655   
    ::aws_smithy_schema::ShapeId::from_static(
  656    656   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ServerSideEncryption",
  657    657   
        "com.amazonaws.s3.synthetic",
  658    658   
        "HeadObjectOutput",
  659    659   
    ),
  660    660   
    ::aws_smithy_schema::ShapeType::String,
  661         -
    "server_side_encryption",
         661  +
    "ServerSideEncryption",
  662    662   
    23,
  663    663   
)
  664    664   
.with_http_header("x-amz-server-side-encryption");
  665    665   
static HEADOBJECTOUTPUT_MEMBER_METADATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  666    666   
    ::aws_smithy_schema::ShapeId::from_static(
  667    667   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$Metadata",
  668    668   
        "com.amazonaws.s3.synthetic",
  669    669   
        "HeadObjectOutput",
  670    670   
    ),
  671    671   
    ::aws_smithy_schema::ShapeType::Map,
  672         -
    "metadata",
         672  +
    "Metadata",
  673    673   
    24,
  674    674   
)
  675    675   
.with_http_prefix_headers("x-amz-meta-");
  676    676   
static HEADOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  677    677   
    ::aws_smithy_schema::ShapeId::from_static(
  678    678   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$SSECustomerAlgorithm",
  679    679   
        "com.amazonaws.s3.synthetic",
  680    680   
        "HeadObjectOutput",
  681    681   
    ),
  682    682   
    ::aws_smithy_schema::ShapeType::String,
  683         -
    "sse_customer_algorithm",
         683  +
    "SSECustomerAlgorithm",
  684    684   
    25,
  685    685   
)
  686    686   
.with_http_header("x-amz-server-side-encryption-customer-algorithm");
  687    687   
static HEADOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  688    688   
    ::aws_smithy_schema::ShapeId::from_static(
  689    689   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$SSECustomerKeyMD5",
  690    690   
        "com.amazonaws.s3.synthetic",
  691    691   
        "HeadObjectOutput",
  692    692   
    ),
  693    693   
    ::aws_smithy_schema::ShapeType::String,
  694         -
    "sse_customer_key_md5",
         694  +
    "SSECustomerKeyMD5",
  695    695   
    26,
  696    696   
)
  697    697   
.with_http_header("x-amz-server-side-encryption-customer-key-MD5");
  698    698   
static HEADOBJECTOUTPUT_MEMBER_SSEKMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  699    699   
    ::aws_smithy_schema::ShapeId::from_static(
  700    700   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$SSEKMSKeyId",
  701    701   
        "com.amazonaws.s3.synthetic",
  702    702   
        "HeadObjectOutput",
  703    703   
    ),
  704    704   
    ::aws_smithy_schema::ShapeType::String,
  705         -
    "ssekms_key_id",
         705  +
    "SSEKMSKeyId",
  706    706   
    27,
  707    707   
)
  708    708   
.with_http_header("x-amz-server-side-encryption-aws-kms-key-id");
  709    709   
static HEADOBJECTOUTPUT_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  710    710   
    ::aws_smithy_schema::ShapeId::from_static(
  711    711   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$BucketKeyEnabled",
  712    712   
        "com.amazonaws.s3.synthetic",
  713    713   
        "HeadObjectOutput",
  714    714   
    ),
  715    715   
    ::aws_smithy_schema::ShapeType::Boolean,
  716         -
    "bucket_key_enabled",
         716  +
    "BucketKeyEnabled",
  717    717   
    28,
  718    718   
)
  719    719   
.with_http_header("x-amz-server-side-encryption-bucket-key-enabled");
  720    720   
static HEADOBJECTOUTPUT_MEMBER_STORAGE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  721    721   
    ::aws_smithy_schema::ShapeId::from_static(
  722    722   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$StorageClass",
  723    723   
        "com.amazonaws.s3.synthetic",
  724    724   
        "HeadObjectOutput",
  725    725   
    ),
  726    726   
    ::aws_smithy_schema::ShapeType::String,
  727         -
    "storage_class",
         727  +
    "StorageClass",
  728    728   
    29,
  729    729   
)
  730    730   
.with_http_header("x-amz-storage-class");
  731    731   
static HEADOBJECTOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  732    732   
    ::aws_smithy_schema::ShapeId::from_static(
  733    733   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$RequestCharged",
  734    734   
        "com.amazonaws.s3.synthetic",
  735    735   
        "HeadObjectOutput",
  736    736   
    ),
  737    737   
    ::aws_smithy_schema::ShapeType::String,
  738         -
    "request_charged",
         738  +
    "RequestCharged",
  739    739   
    30,
  740    740   
)
  741    741   
.with_http_header("x-amz-request-charged");
  742    742   
static HEADOBJECTOUTPUT_MEMBER_REPLICATION_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  743    743   
    ::aws_smithy_schema::ShapeId::from_static(
  744    744   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ReplicationStatus",
  745    745   
        "com.amazonaws.s3.synthetic",
  746    746   
        "HeadObjectOutput",
  747    747   
    ),
  748    748   
    ::aws_smithy_schema::ShapeType::String,
  749         -
    "replication_status",
         749  +
    "ReplicationStatus",
  750    750   
    31,
  751    751   
)
  752    752   
.with_http_header("x-amz-replication-status");
  753    753   
static HEADOBJECTOUTPUT_MEMBER_PARTS_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  754    754   
    ::aws_smithy_schema::ShapeId::from_static(
  755    755   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$PartsCount",
  756    756   
        "com.amazonaws.s3.synthetic",
  757    757   
        "HeadObjectOutput",
  758    758   
    ),
  759    759   
    ::aws_smithy_schema::ShapeType::Integer,
  760         -
    "parts_count",
         760  +
    "PartsCount",
  761    761   
    32,
  762    762   
)
  763    763   
.with_http_header("x-amz-mp-parts-count");
  764    764   
static HEADOBJECTOUTPUT_MEMBER_TAG_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  765    765   
    ::aws_smithy_schema::ShapeId::from_static(
  766    766   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$TagCount",
  767    767   
        "com.amazonaws.s3.synthetic",
  768    768   
        "HeadObjectOutput",
  769    769   
    ),
  770    770   
    ::aws_smithy_schema::ShapeType::Integer,
  771         -
    "tag_count",
         771  +
    "TagCount",
  772    772   
    33,
  773    773   
)
  774    774   
.with_http_header("x-amz-tagging-count");
  775    775   
static HEADOBJECTOUTPUT_MEMBER_OBJECT_LOCK_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  776    776   
    ::aws_smithy_schema::ShapeId::from_static(
  777    777   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ObjectLockMode",
  778    778   
        "com.amazonaws.s3.synthetic",
  779    779   
        "HeadObjectOutput",
  780    780   
    ),
  781    781   
    ::aws_smithy_schema::ShapeType::String,
  782         -
    "object_lock_mode",
         782  +
    "ObjectLockMode",
  783    783   
    34,
  784    784   
)
  785    785   
.with_http_header("x-amz-object-lock-mode");
  786    786   
static HEADOBJECTOUTPUT_MEMBER_OBJECT_LOCK_RETAIN_UNTIL_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  787    787   
    ::aws_smithy_schema::ShapeId::from_static(
  788    788   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ObjectLockRetainUntilDate",
  789    789   
        "com.amazonaws.s3.synthetic",
  790    790   
        "HeadObjectOutput",
  791    791   
    ),
  792    792   
    ::aws_smithy_schema::ShapeType::Timestamp,
  793         -
    "object_lock_retain_until_date",
         793  +
    "ObjectLockRetainUntilDate",
  794    794   
    35,
  795    795   
)
  796         -
.with_http_header("x-amz-object-lock-retain-until-date");
         796  +
.with_http_header("x-amz-object-lock-retain-until-date")
         797  +
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
  797    798   
static HEADOBJECTOUTPUT_MEMBER_OBJECT_LOCK_LEGAL_HOLD_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  798    799   
    ::aws_smithy_schema::ShapeId::from_static(
  799    800   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ObjectLockLegalHoldStatus",
  800    801   
        "com.amazonaws.s3.synthetic",
  801    802   
        "HeadObjectOutput",
  802    803   
    ),
  803    804   
    ::aws_smithy_schema::ShapeType::String,
  804         -
    "object_lock_legal_hold_status",
         805  +
    "ObjectLockLegalHoldStatus",
  805    806   
    36,
  806    807   
)
  807    808   
.with_http_header("x-amz-object-lock-legal-hold");
  808    809   
static HEADOBJECTOUTPUT_MEMBER_EXPIRES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  809    810   
    ::aws_smithy_schema::ShapeId::from_static(
  810    811   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$Expires",
  811    812   
        "com.amazonaws.s3.synthetic",
  812    813   
        "HeadObjectOutput",
  813    814   
    ),
  814    815   
    ::aws_smithy_schema::ShapeType::Timestamp,
  815         -
    "expires",
         816  +
    "Expires",
  816    817   
    37,
  817    818   
)
  818    819   
.with_http_header("Expires");
  819    820   
static HEADOBJECTOUTPUT_MEMBER_EXPIRES_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  820    821   
    ::aws_smithy_schema::ShapeId::from_static(
  821    822   
        "com.amazonaws.s3.synthetic#HeadObjectOutput$ExpiresString",
  822    823   
        "com.amazonaws.s3.synthetic",
  823    824   
        "HeadObjectOutput",
  824    825   
    ),
  825    826   
    ::aws_smithy_schema::ShapeType::String,
  826         -
    "expires_string",
         827  +
    "ExpiresString",
  827    828   
    38,
  828    829   
)
  829    830   
.with_http_header("ExpiresString");
         831  +
static HEADOBJECTOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         832  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         833  +
    ::aws_smithy_schema::ShapeType::String,
         834  +
    "request_id",
         835  +
    39,
         836  +
)
         837  +
.with_http_header("x-amzn-requestid");
  830    838   
static HEADOBJECTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  831    839   
    HEADOBJECTOUTPUT_SCHEMA_ID,
  832    840   
    ::aws_smithy_schema::ShapeType::Structure,
  833    841   
    &[
  834    842   
        &HEADOBJECTOUTPUT_MEMBER_DELETE_MARKER,
  835    843   
        &HEADOBJECTOUTPUT_MEMBER_ACCEPT_RANGES,
  836    844   
        &HEADOBJECTOUTPUT_MEMBER_EXPIRATION,
  837    845   
        &HEADOBJECTOUTPUT_MEMBER_RESTORE,
  838    846   
        &HEADOBJECTOUTPUT_MEMBER_ARCHIVE_STATUS,
  839    847   
        &HEADOBJECTOUTPUT_MEMBER_LAST_MODIFIED,
  840    848   
        &HEADOBJECTOUTPUT_MEMBER_CONTENT_LENGTH,
  841    849   
        &HEADOBJECTOUTPUT_MEMBER_CHECKSUM_CRC32,
  842    850   
        &HEADOBJECTOUTPUT_MEMBER_CHECKSUM_CRC32_C,
  843    851   
        &HEADOBJECTOUTPUT_MEMBER_CHECKSUM_CRC64_NVME,
  844    852   
        &HEADOBJECTOUTPUT_MEMBER_CHECKSUM_SHA1,
  845    853   
        &HEADOBJECTOUTPUT_MEMBER_CHECKSUM_SHA256,
  846    854   
        &HEADOBJECTOUTPUT_MEMBER_CHECKSUM_TYPE,
  847    855   
        &HEADOBJECTOUTPUT_MEMBER_E_TAG,
  848    856   
        &HEADOBJECTOUTPUT_MEMBER_MISSING_META,
  849    857   
        &HEADOBJECTOUTPUT_MEMBER_VERSION_ID,
  850    858   
        &HEADOBJECTOUTPUT_MEMBER_CACHE_CONTROL,
  851    859   
        &HEADOBJECTOUTPUT_MEMBER_CONTENT_DISPOSITION,
  852    860   
        &HEADOBJECTOUTPUT_MEMBER_CONTENT_ENCODING,
  853    861   
        &HEADOBJECTOUTPUT_MEMBER_CONTENT_LANGUAGE,
  854    862   
        &HEADOBJECTOUTPUT_MEMBER_CONTENT_TYPE,
  855    863   
        &HEADOBJECTOUTPUT_MEMBER_CONTENT_RANGE,
  856    864   
        &HEADOBJECTOUTPUT_MEMBER_WEBSITE_REDIRECT_LOCATION,
  857    865   
        &HEADOBJECTOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION,
  858    866   
        &HEADOBJECTOUTPUT_MEMBER_METADATA,
  859    867   
        &HEADOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
  860    868   
        &HEADOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
  861    869   
        &HEADOBJECTOUTPUT_MEMBER_SSEKMS_KEY_ID,
  862    870   
        &HEADOBJECTOUTPUT_MEMBER_BUCKET_KEY_ENABLED,
  863    871   
        &HEADOBJECTOUTPUT_MEMBER_STORAGE_CLASS,
  864    872   
        &HEADOBJECTOUTPUT_MEMBER_REQUEST_CHARGED,
  865    873   
        &HEADOBJECTOUTPUT_MEMBER_REPLICATION_STATUS,
  866    874   
        &HEADOBJECTOUTPUT_MEMBER_PARTS_COUNT,
  867    875   
        &HEADOBJECTOUTPUT_MEMBER_TAG_COUNT,
  868    876   
        &HEADOBJECTOUTPUT_MEMBER_OBJECT_LOCK_MODE,
  869    877   
        &HEADOBJECTOUTPUT_MEMBER_OBJECT_LOCK_RETAIN_UNTIL_DATE,
  870    878   
        &HEADOBJECTOUTPUT_MEMBER_OBJECT_LOCK_LEGAL_HOLD_STATUS,
  871    879   
        &HEADOBJECTOUTPUT_MEMBER_EXPIRES,
  872    880   
        &HEADOBJECTOUTPUT_MEMBER_EXPIRES_STRING,
         881  +
        &HEADOBJECTOUTPUT_MEMBER__REQUEST_ID,
  873    882   
    ],
  874    883   
);
  875    884   
impl HeadObjectOutput {
  876    885   
    /// The schema for this shape.
  877    886   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HEADOBJECTOUTPUT_SCHEMA;
  878    887   
}
  879    888   
impl ::aws_smithy_schema::serde::SerializableStruct for HeadObjectOutput {
  880    889   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  881    890   
    fn serialize_members(
  882    891   
        &self,
@@ -986,995 +1058,1067 @@
 1006   1015   
            ser.write_timestamp(&HEADOBJECTOUTPUT_MEMBER_EXPIRES, val)?;
 1007   1016   
        }
 1008   1017   
        if let Some(ref val) = self.expires_string {
 1009   1018   
            ser.write_string(&HEADOBJECTOUTPUT_MEMBER_EXPIRES_STRING, val)?;
 1010   1019   
        }
 1011   1020   
        Ok(())
 1012   1021   
    }
 1013   1022   
}
 1014   1023   
impl HeadObjectOutput {
 1015   1024   
    /// Deserializes this structure from a [`ShapeDeserializer`].
 1016         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
 1017         -
        deserializer: &mut D,
        1025  +
    pub fn deserialize(
        1026  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
 1018   1027   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
 1019   1028   
        #[allow(unused_variables, unused_mut)]
 1020   1029   
        let mut builder = Self::builder();
 1021   1030   
        #[allow(
 1022   1031   
            unused_variables,
 1023   1032   
            unreachable_code,
 1024   1033   
            clippy::single_match,
 1025   1034   
            clippy::match_single_binding,
 1026   1035   
            clippy::diverging_sub_expression
 1027   1036   
        )]
 1028         -
        deserializer.read_struct(&HEADOBJECTOUTPUT_SCHEMA, (), |_, member, deser| {
        1037  +
        deserializer.read_struct(&HEADOBJECTOUTPUT_SCHEMA, &mut |member, deser| {
 1029   1038   
            match member.member_index() {
 1030   1039   
                Some(0) => {
 1031   1040   
                    builder.delete_marker = Some(deser.read_boolean(member)?);
 1032   1041   
                }
 1033   1042   
                Some(1) => {
 1034   1043   
                    builder.accept_ranges = Some(deser.read_string(member)?);
 1035   1044   
                }
 1036   1045   
                Some(2) => {
 1037   1046   
                    builder.expiration = Some(deser.read_string(member)?);
 1038   1047   
                }
@@ -1073,1082 +1193,1338 @@
 1093   1102   
                Some(21) => {
 1094   1103   
                    builder.content_range = Some(deser.read_string(member)?);
 1095   1104   
                }
 1096   1105   
                Some(22) => {
 1097   1106   
                    builder.website_redirect_location = Some(deser.read_string(member)?);
 1098   1107   
                }
 1099   1108   
                Some(23) => {
 1100   1109   
                    builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
 1101   1110   
                }
 1102   1111   
                Some(24) => {
 1103         -
                    builder.metadata = Some({
 1104         -
                        let container = if let Some(cap) = deser.container_size() {
 1105         -
                            std::collections::HashMap::with_capacity(cap)
 1106         -
                        } else {
 1107         -
                            std::collections::HashMap::new()
 1108         -
                        };
 1109         -
                        deser.read_map(member, container, |mut map, key, deser| {
 1110         -
                            map.insert(key, deser.read_string(member)?);
 1111         -
                            Ok(map)
 1112         -
                        })?
 1113         -
                    });
        1112  +
                    builder.metadata = Some(deser.read_string_string_map(member)?);
 1114   1113   
                }
 1115   1114   
                Some(25) => {
 1116   1115   
                    builder.sse_customer_algorithm = Some(deser.read_string(member)?);
 1117   1116   
                }
 1118   1117   
                Some(26) => {
 1119   1118   
                    builder.sse_customer_key_md5 = Some(deser.read_string(member)?);
 1120   1119   
                }
 1121   1120   
                Some(27) => {
 1122   1121   
                    builder.ssekms_key_id = Some(deser.read_string(member)?);
 1123   1122   
                }
 1124   1123   
                Some(28) => {
 1125   1124   
                    builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
 1126   1125   
                }
 1127   1126   
                Some(29) => {
 1128   1127   
                    builder.storage_class = Some(crate::types::StorageClass::from(deser.read_string(member)?.as_str()));
 1129   1128   
                }
 1130   1129   
                Some(30) => {
 1131   1130   
                    builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
 1132   1131   
                }
 1133   1132   
                Some(31) => {
 1134   1133   
                    builder.replication_status = Some(crate::types::ReplicationStatus::from(deser.read_string(member)?.as_str()));
 1135   1134   
                }
 1136   1135   
                Some(32) => {
 1137   1136   
                    builder.parts_count = Some(deser.read_integer(member)?);
 1138   1137   
                }
 1139   1138   
                Some(33) => {
 1140   1139   
                    builder.tag_count = Some(deser.read_integer(member)?);
 1141   1140   
                }
 1142   1141   
                Some(34) => {
 1143   1142   
                    builder.object_lock_mode = Some(crate::types::ObjectLockMode::from(deser.read_string(member)?.as_str()));
 1144   1143   
                }
 1145   1144   
                Some(35) => {
 1146   1145   
                    builder.object_lock_retain_until_date = Some(deser.read_timestamp(member)?);
 1147   1146   
                }
 1148   1147   
                Some(36) => {
 1149   1148   
                    builder.object_lock_legal_hold_status = Some(crate::types::ObjectLockLegalHoldStatus::from(deser.read_string(member)?.as_str()));
 1150   1149   
                }
 1151   1150   
                Some(37) => {
 1152   1151   
                    builder.expires = Some(deser.read_timestamp(member)?);
 1153   1152   
                }
 1154   1153   
                Some(38) => {
 1155   1154   
                    builder.expires_string = Some(deser.read_string(member)?);
 1156   1155   
                }
        1156  +
                Some(39) => {
        1157  +
                    builder._request_id = Some(deser.read_string(member)?);
        1158  +
                }
 1157   1159   
                _ => {}
 1158   1160   
            }
 1159   1161   
            Ok(())
 1160   1162   
        })?;
 1161   1163   
        Ok(builder.build())
 1162   1164   
    }
 1163   1165   
}
        1166  +
impl HeadObjectOutput {
        1167  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
        1168  +
    /// Header-bound members are read directly from headers, avoiding runtime
        1169  +
    /// member iteration overhead. Body members are read via the deserializer.
        1170  +
    pub fn deserialize_with_response(
        1171  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
        1172  +
        headers: &::aws_smithy_runtime_api::http::Headers,
        1173  +
        _status: u16,
        1174  +
        _body: &[u8],
        1175  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
        1176  +
        #[allow(unused_variables, unused_mut)]
        1177  +
        let mut builder = Self::builder();
        1178  +
        if let Some(val) = headers.get("x-amz-delete-marker") {
        1179  +
            builder.delete_marker = val.parse::<bool>().ok();
        1180  +
        }
        1181  +
        if let Some(val) = headers.get("accept-ranges") {
        1182  +
            builder.accept_ranges = Some(val.to_string());
        1183  +
        }
        1184  +
        if let Some(val) = headers.get("x-amz-expiration") {
        1185  +
            builder.expiration = Some(val.to_string());
        1186  +
        }
        1187  +
        if let Some(val) = headers.get("x-amz-restore") {
        1188  +
            builder.restore = Some(val.to_string());
        1189  +
        }
        1190  +
        if let Some(val) = headers.get("x-amz-archive-status") {
        1191  +
            builder.archive_status = Some(crate::types::ArchiveStatus::from(val));
        1192  +
        }
        1193  +
        if let Some(val) = headers.get("Last-Modified") {
        1194  +
            builder.last_modified = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
        1195  +
        }
        1196  +
        if let Some(val) = headers.get("Content-Length") {
        1197  +
            builder.content_length = val.parse::<i64>().ok();
        1198  +
        }
        1199  +
        if let Some(val) = headers.get("x-amz-checksum-crc32") {
        1200  +
            builder.checksum_crc32 = Some(val.to_string());
        1201  +
        }
        1202  +
        if let Some(val) = headers.get("x-amz-checksum-crc32c") {
        1203  +
            builder.checksum_crc32_c = Some(val.to_string());
        1204  +
        }
        1205  +
        if let Some(val) = headers.get("x-amz-checksum-crc64nvme") {
        1206  +
            builder.checksum_crc64_nvme = Some(val.to_string());
        1207  +
        }
        1208  +
        if let Some(val) = headers.get("x-amz-checksum-sha1") {
        1209  +
            builder.checksum_sha1 = Some(val.to_string());
        1210  +
        }
        1211  +
        if let Some(val) = headers.get("x-amz-checksum-sha256") {
        1212  +
            builder.checksum_sha256 = Some(val.to_string());
        1213  +
        }
        1214  +
        if let Some(val) = headers.get("x-amz-checksum-type") {
        1215  +
            builder.checksum_type = Some(crate::types::ChecksumType::from(val));
        1216  +
        }
        1217  +
        if let Some(val) = headers.get("ETag") {
        1218  +
            builder.e_tag = Some(val.to_string());
        1219  +
        }
        1220  +
        if let Some(val) = headers.get("x-amz-missing-meta") {
        1221  +
            builder.missing_meta = val.parse::<i32>().ok();
        1222  +
        }
        1223  +
        if let Some(val) = headers.get("x-amz-version-id") {
        1224  +
            builder.version_id = Some(val.to_string());
        1225  +
        }
        1226  +
        if let Some(val) = headers.get("Cache-Control") {
        1227  +
            builder.cache_control = Some(val.to_string());
        1228  +
        }
        1229  +
        if let Some(val) = headers.get("Content-Disposition") {
        1230  +
            builder.content_disposition = Some(val.to_string());
        1231  +
        }
        1232  +
        if let Some(val) = headers.get("Content-Encoding") {
        1233  +
            builder.content_encoding = Some(val.to_string());
        1234  +
        }
        1235  +
        if let Some(val) = headers.get("Content-Language") {
        1236  +
            builder.content_language = Some(val.to_string());
        1237  +
        }
        1238  +
        if let Some(val) = headers.get("Content-Type") {
        1239  +
            builder.content_type = Some(val.to_string());
        1240  +
        }
        1241  +
        if let Some(val) = headers.get("Content-Range") {
        1242  +
            builder.content_range = Some(val.to_string());
        1243  +
        }
        1244  +
        if let Some(val) = headers.get("x-amz-website-redirect-location") {
        1245  +
            builder.website_redirect_location = Some(val.to_string());
        1246  +
        }
        1247  +
        if let Some(val) = headers.get("x-amz-server-side-encryption") {
        1248  +
            builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(val));
        1249  +
        }
        1250  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
        1251  +
            builder.sse_customer_algorithm = Some(val.to_string());
        1252  +
        }
        1253  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
        1254  +
            builder.sse_customer_key_md5 = Some(val.to_string());
        1255  +
        }
        1256  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-aws-kms-key-id") {
        1257  +
            builder.ssekms_key_id = Some(val.to_string());
        1258  +
        }
        1259  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-bucket-key-enabled") {
        1260  +
            builder.bucket_key_enabled = val.parse::<bool>().ok();
        1261  +
        }
        1262  +
        if let Some(val) = headers.get("x-amz-storage-class") {
        1263  +
            builder.storage_class = Some(crate::types::StorageClass::from(val));
        1264  +
        }
        1265  +
        if let Some(val) = headers.get("x-amz-request-charged") {
        1266  +
            builder.request_charged = Some(crate::types::RequestCharged::from(val));
        1267  +
        }
        1268  +
        if let Some(val) = headers.get("x-amz-replication-status") {
        1269  +
            builder.replication_status = Some(crate::types::ReplicationStatus::from(val));
        1270  +
        }
        1271  +
        if let Some(val) = headers.get("x-amz-mp-parts-count") {
        1272  +
            builder.parts_count = val.parse::<i32>().ok();
        1273  +
        }
        1274  +
        if let Some(val) = headers.get("x-amz-tagging-count") {
        1275  +
            builder.tag_count = val.parse::<i32>().ok();
        1276  +
        }
        1277  +
        if let Some(val) = headers.get("x-amz-object-lock-mode") {
        1278  +
            builder.object_lock_mode = Some(crate::types::ObjectLockMode::from(val));
        1279  +
        }
        1280  +
        if let Some(val) = headers.get("x-amz-object-lock-retain-until-date") {
        1281  +
            builder.object_lock_retain_until_date = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::DateTime).ok();
        1282  +
        }
        1283  +
        if let Some(val) = headers.get("x-amz-object-lock-legal-hold") {
        1284  +
            builder.object_lock_legal_hold_status = Some(crate::types::ObjectLockLegalHoldStatus::from(val));
        1285  +
        }
        1286  +
        if let Some(val) = headers.get("Expires") {
        1287  +
            builder.expires = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
        1288  +
        }
        1289  +
        if let Some(val) = headers.get("ExpiresString") {
        1290  +
            builder.expires_string = Some(val.to_string());
        1291  +
        }
        1292  +
        if let Some(val) = headers.get("x-amzn-requestid") {
        1293  +
            builder._request_id = Some(val.to_string());
        1294  +
        }
        1295  +
        {
        1296  +
            let mut map = ::std::collections::HashMap::new();
        1297  +
            for (key, val) in headers.iter() {
        1298  +
                if let Some(suffix) = key.strip_prefix("x-amz-meta-") {
        1299  +
                    map.insert(suffix.to_string(), val.to_string());
        1300  +
                }
        1301  +
            }
        1302  +
            if !map.is_empty() {
        1303  +
                builder.metadata = Some(map);
        1304  +
            }
        1305  +
        }
        1306  +
        Ok(builder.build())
        1307  +
    }
        1308  +
}
 1164   1309   
impl crate::s3_request_id::RequestIdExt for HeadObjectOutput {
 1165   1310   
    fn extended_request_id(&self) -> Option<&str> {
 1166   1311   
        self._extended_request_id.as_deref()
 1167   1312   
    }
 1168   1313   
}
 1169   1314   
impl ::aws_types::request_id::RequestId for HeadObjectOutput {
 1170   1315   
    fn request_id(&self) -> Option<&str> {
 1171   1316   
        self._request_id.as_deref()
 1172   1317   
    }
 1173   1318   
}

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

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

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

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