AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045 (ignoring whitespace)

Files changed:

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

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

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

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GetBucketReplication`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetBucketReplication;
    6      6   
impl GetBucketReplication {
    7      7   
    /// Creates a new `GetBucketReplication`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_bucket_replication::GetBucketReplicationInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_bucket_replication::GetBucketReplicationOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::get_bucket_replication::GetBucketReplicationInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_bucket_replication::GetBucketReplicationOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_bucket_replication::GetBucketReplicationError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -118,122 +180,185 @@
  138    142   
                crate::operation::get_bucket_replication::GetBucketReplicationError,
  139    143   
            >::new());
  140    144   
  141    145   
        ::std::borrow::Cow::Owned(rcb)
  142    146   
    }
  143    147   
}
  144    148   
  145    149   
#[derive(Debug)]
  146    150   
struct GetBucketReplicationResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketReplicationResponseDeserializer {
  148         -
    fn deserialize_nonstreaming(
         152  +
    fn deserialize_nonstreaming_with_config(
  149    153   
        &self,
  150    154   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         155  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    156   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    157   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153    158   
        let headers = response.headers();
  154    159   
        let body = response.body().bytes().expect("body loaded");
  155    160   
        #[allow(unused_mut)]
  156    161   
        let mut force_error = false;
  157    162   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  158    163   
        let parse_result = if !success && status != 200 || force_error {
  159    164   
            crate::protocol_serde::shape_get_bucket_replication::de_get_bucket_replication_http_error(status, headers, body)
  160    165   
        } else {

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

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

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

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

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

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GetBucketTagging`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetBucketTagging;
    6      6   
impl GetBucketTagging {
    7      7   
    /// Creates a new `GetBucketTagging`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_bucket_tagging::GetBucketTaggingInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_bucket_tagging::GetBucketTaggingOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::get_bucket_tagging::GetBucketTaggingInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_bucket_tagging::GetBucketTaggingOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_bucket_tagging::GetBucketTaggingError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -118,122 +180,185 @@
  138    142   
                crate::operation::get_bucket_tagging::GetBucketTaggingError,
  139    143   
            >::new());
  140    144   
  141    145   
        ::std::borrow::Cow::Owned(rcb)
  142    146   
    }
  143    147   
}
  144    148   
  145    149   
#[derive(Debug)]
  146    150   
struct GetBucketTaggingResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketTaggingResponseDeserializer {
  148         -
    fn deserialize_nonstreaming(
         152  +
    fn deserialize_nonstreaming_with_config(
  149    153   
        &self,
  150    154   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         155  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    156   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    157   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153    158   
        let headers = response.headers();
  154    159   
        let body = response.body().bytes().expect("body loaded");
  155    160   
        #[allow(unused_mut)]
  156    161   
        let mut force_error = false;
  157    162   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  158    163   
        let parse_result = if !success && status != 200 || force_error {
  159    164   
            crate::protocol_serde::shape_get_bucket_tagging::de_get_bucket_tagging_http_error(status, headers, body)
  160    165   
        } else {

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/get_bucket_tagging/_get_bucket_tagging_input.rs

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

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

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

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

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GetBucketVersioning`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetBucketVersioning;
    6      6   
impl GetBucketVersioning {
    7      7   
    /// Creates a new `GetBucketVersioning`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_bucket_versioning::GetBucketVersioningInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_bucket_versioning::GetBucketVersioningOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::get_bucket_versioning::GetBucketVersioningInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_bucket_versioning::GetBucketVersioningOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_bucket_versioning::GetBucketVersioningError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -118,122 +180,185 @@
  138    142   
                crate::operation::get_bucket_versioning::GetBucketVersioningError,
  139    143   
            >::new());
  140    144   
  141    145   
        ::std::borrow::Cow::Owned(rcb)
  142    146   
    }
  143    147   
}
  144    148   
  145    149   
#[derive(Debug)]
  146    150   
struct GetBucketVersioningResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetBucketVersioningResponseDeserializer {
  148         -
    fn deserialize_nonstreaming(
         152  +
    fn deserialize_nonstreaming_with_config(
  149    153   
        &self,
  150    154   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         155  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    156   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    157   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153    158   
        let headers = response.headers();
  154    159   
        let body = response.body().bytes().expect("body loaded");
  155    160   
        #[allow(unused_mut)]
  156    161   
        let mut force_error = false;
  157    162   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  158    163   
        let parse_result = if !success && status != 200 || force_error {
  159    164   
            crate::protocol_serde::shape_get_bucket_versioning::de_get_bucket_versioning_http_error(status, headers, body)
  160    165   
        } else {

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

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/get_bucket_versioning/_get_bucket_versioning_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/get_data_access.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 `GetDataAccess`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetDataAccess;
    6      6   
impl GetDataAccess {
    7      7   
    /// Creates a new `GetDataAccess`
    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_data_access::GetDataAccessInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_data_access::GetDataAccessOutput::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_data_access::GetDataAccessInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_data_access::GetDataAccessOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_data_access::GetDataAccessError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -119,123 +181,186 @@
  139    143   
                crate::operation::get_data_access::GetDataAccessError,
  140    144   
            >::new());
  141    145   
  142    146   
        ::std::borrow::Cow::Owned(rcb)
  143    147   
    }
  144    148   
}
  145    149   
  146    150   
#[derive(Debug)]
  147    151   
struct GetDataAccessResponseDeserializer;
  148    152   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetDataAccessResponseDeserializer {
  149         -
    fn deserialize_nonstreaming(
         153  +
    fn deserialize_nonstreaming_with_config(
  150    154   
        &self,
  151    155   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         156  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  152    157   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  153    158   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  154    159   
        let headers = response.headers();
  155    160   
        let body = response.body().bytes().expect("body loaded");
  156    161   
        #[allow(unused_mut)]
  157    162   
        let mut force_error = false;
  158    163   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  159    164   
        let parse_result = if !success && status != 200 || force_error {
  160    165   
            crate::protocol_serde::shape_get_data_access::de_get_data_access_http_error(status, headers, body)
  161    166   
        } else {

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/get_data_access/_get_data_access_input.rs

@@ -55,55 +255,311 @@
   75     75   
    "com.amazonaws.s3control.synthetic",
   76     76   
    "GetDataAccessInput",
   77     77   
);
   78     78   
static GETDATAACCESSINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.s3control.synthetic#GetDataAccessInput$AccountId",
   81     81   
        "com.amazonaws.s3control.synthetic",
   82     82   
        "GetDataAccessInput",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::String,
   85         -
    "account_id",
          85  +
    "AccountId",
   86     86   
    0,
   87     87   
)
   88     88   
.with_host_label()
   89     89   
.with_http_header("x-amz-account-id");
   90     90   
static GETDATAACCESSINPUT_MEMBER_TARGET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.s3control.synthetic#GetDataAccessInput$Target",
   93     93   
        "com.amazonaws.s3control.synthetic",
   94     94   
        "GetDataAccessInput",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::String,
   97         -
    "target",
          97  +
    "Target",
   98     98   
    1,
   99     99   
)
  100    100   
.with_http_query("target");
  101    101   
static GETDATAACCESSINPUT_MEMBER_PERMISSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.s3control.synthetic#GetDataAccessInput$Permission",
  104    104   
        "com.amazonaws.s3control.synthetic",
  105    105   
        "GetDataAccessInput",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "permission",
         108  +
    "Permission",
  109    109   
    2,
  110    110   
)
  111    111   
.with_http_query("permission");
  112    112   
static GETDATAACCESSINPUT_MEMBER_DURATION_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.s3control.synthetic#GetDataAccessInput$DurationSeconds",
  115    115   
        "com.amazonaws.s3control.synthetic",
  116    116   
        "GetDataAccessInput",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::Integer,
  119         -
    "duration_seconds",
         119  +
    "DurationSeconds",
  120    120   
    3,
  121    121   
)
  122    122   
.with_http_query("durationSeconds");
  123    123   
static GETDATAACCESSINPUT_MEMBER_PRIVILEGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.s3control.synthetic#GetDataAccessInput$Privilege",
  126    126   
        "com.amazonaws.s3control.synthetic",
  127    127   
        "GetDataAccessInput",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::String,
  130         -
    "privilege",
         130  +
    "Privilege",
  131    131   
    4,
  132    132   
)
  133    133   
.with_http_query("privilege");
  134    134   
static GETDATAACCESSINPUT_MEMBER_TARGET_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "com.amazonaws.s3control.synthetic#GetDataAccessInput$TargetType",
  137    137   
        "com.amazonaws.s3control.synthetic",
  138    138   
        "GetDataAccessInput",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::String,
  141         -
    "target_type",
         141  +
    "TargetType",
  142    142   
    5,
  143    143   
)
  144    144   
.with_http_query("targetType");
  145    145   
static GETDATAACCESSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  146    146   
    GETDATAACCESSINPUT_SCHEMA_ID,
  147    147   
    ::aws_smithy_schema::ShapeType::Structure,
  148    148   
    &[
  149    149   
        &GETDATAACCESSINPUT_MEMBER_ACCOUNT_ID,
  150    150   
        &GETDATAACCESSINPUT_MEMBER_TARGET,
  151    151   
        &GETDATAACCESSINPUT_MEMBER_PERMISSION,
  152    152   
        &GETDATAACCESSINPUT_MEMBER_DURATION_SECONDS,
  153    153   
        &GETDATAACCESSINPUT_MEMBER_PRIVILEGE,
  154    154   
        &GETDATAACCESSINPUT_MEMBER_TARGET_TYPE,
  155    155   
    ],
  156         -
);
         156  +
)
         157  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
         158  +
    "GET",
         159  +
    "/v20180820/accessgrantsinstance/dataaccess",
         160  +
    None,
         161  +
));
  157    162   
impl GetDataAccessInput {
  158    163   
    /// The schema for this shape.
  159    164   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETDATAACCESSINPUT_SCHEMA;
  160    165   
}
  161    166   
impl ::aws_smithy_schema::serde::SerializableStruct for GetDataAccessInput {
  162    167   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  163    168   
    fn serialize_members(
  164    169   
        &self,
  165    170   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  166    171   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  167    172   
        if let Some(ref val) = self.account_id {
  168    173   
            ser.write_string(&GETDATAACCESSINPUT_MEMBER_ACCOUNT_ID, val)?;
  169    174   
        }
  170    175   
        if let Some(ref val) = self.target {
  171    176   
            ser.write_string(&GETDATAACCESSINPUT_MEMBER_TARGET, val)?;
  172    177   
        }
  173    178   
        if let Some(ref val) = self.permission {
  174    179   
            ser.write_string(&GETDATAACCESSINPUT_MEMBER_PERMISSION, val.as_str())?;
  175    180   
        }
  176    181   
        if let Some(ref val) = self.duration_seconds {
  177    182   
            ser.write_integer(&GETDATAACCESSINPUT_MEMBER_DURATION_SECONDS, *val)?;
  178    183   
        }
  179    184   
        if let Some(ref val) = self.privilege {
  180    185   
            ser.write_string(&GETDATAACCESSINPUT_MEMBER_PRIVILEGE, val.as_str())?;
  181    186   
        }
  182    187   
        if let Some(ref val) = self.target_type {
  183    188   
            ser.write_string(&GETDATAACCESSINPUT_MEMBER_TARGET_TYPE, val.as_str())?;
  184    189   
        }
  185    190   
        Ok(())
  186    191   
    }
  187    192   
}
  188    193   
impl GetDataAccessInput {
  189    194   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  190         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  191         -
        deserializer: &mut D,
         195  +
    pub fn deserialize(
         196  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  192    197   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  193    198   
        #[allow(unused_variables, unused_mut)]
  194    199   
        let mut builder = Self::builder();
  195    200   
        #[allow(
  196    201   
            unused_variables,
  197    202   
            unreachable_code,
  198    203   
            clippy::single_match,
  199    204   
            clippy::match_single_binding,
  200    205   
            clippy::diverging_sub_expression
  201    206   
        )]
  202         -
        deserializer.read_struct(&GETDATAACCESSINPUT_SCHEMA, (), |_, member, deser| {
         207  +
        deserializer.read_struct(&GETDATAACCESSINPUT_SCHEMA, &mut |member, deser| {
  203    208   
            match member.member_index() {
  204    209   
                Some(0) => {
  205    210   
                    builder.account_id = Some(deser.read_string(member)?);
  206    211   
                }
  207    212   
                Some(1) => {
  208    213   
                    builder.target = Some(deser.read_string(member)?);
  209    214   
                }
  210    215   
                Some(2) => {
  211    216   
                    builder.permission = Some(crate::types::Permission::from(deser.read_string(member)?.as_str()));
  212    217   
                }
  213    218   
                Some(3) => {
  214    219   
                    builder.duration_seconds = Some(deser.read_integer(member)?);
  215    220   
                }
  216    221   
                Some(4) => {
  217    222   
                    builder.privilege = Some(crate::types::Privilege::from(deser.read_string(member)?.as_str()));
  218    223   
                }
  219    224   
                Some(5) => {
  220    225   
                    builder.target_type = Some(crate::types::S3PrefixType::from(deser.read_string(member)?.as_str()));
  221    226   
                }
  222    227   
                _ => {}
  223    228   
            }
  224    229   
            Ok(())
  225    230   
        })?;
         231  +
        builder.account_id = builder.account_id.or(Some(String::new()));
         232  +
        builder.target = builder.target.or(Some(String::new()));
         233  +
        builder
         234  +
            .build()
         235  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         236  +
    }
         237  +
}
         238  +
impl GetDataAccessInput {
         239  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         240  +
    /// Header-bound members are read directly from headers, avoiding runtime
         241  +
    /// member iteration overhead. Body members are read via the deserializer.
         242  +
    pub fn deserialize_with_response(
         243  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         244  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         245  +
        _status: u16,
         246  +
        _body: &[u8],
         247  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         248  +
        #[allow(unused_variables, unused_mut)]
         249  +
        let mut builder = Self::builder();
         250  +
        if let Some(val) = headers.get("x-amz-account-id") {
         251  +
            builder.account_id = Some(val.to_string());
         252  +
        }
         253  +
        #[allow(
         254  +
            unused_variables,
         255  +
            unreachable_code,
         256  +
            clippy::single_match,
         257  +
            clippy::match_single_binding,
         258  +
            clippy::diverging_sub_expression
         259  +
        )]
         260  +
        deserializer.read_struct(&GETDATAACCESSINPUT_SCHEMA, &mut |member, deser| {
         261  +
            match member.member_index() {
         262  +
                Some(0) => { /* read from headers above */ }
         263  +
                Some(1) => {
         264  +
                    builder.target = Some(deser.read_string(member)?);
         265  +
                }
         266  +
                Some(2) => {
         267  +
                    builder.permission = Some(crate::types::Permission::from(deser.read_string(member)?.as_str()));
         268  +
                }
         269  +
                Some(3) => {
         270  +
                    builder.duration_seconds = Some(deser.read_integer(member)?);
         271  +
                }
         272  +
                Some(4) => {
         273  +
                    builder.privilege = Some(crate::types::Privilege::from(deser.read_string(member)?.as_str()));
         274  +
                }
         275  +
                Some(5) => {
         276  +
                    builder.target_type = Some(crate::types::S3PrefixType::from(deser.read_string(member)?.as_str()));
         277  +
                }
         278  +
                _ => {}
         279  +
            }
         280  +
            Ok(())
         281  +
        })?;
  226    282   
        builder
  227    283   
            .build()
  228    284   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  229    285   
    }
  230    286   
}
  231    287   
impl GetDataAccessInput {
  232    288   
    /// Creates a new builder-style object to manufacture [`GetDataAccessInput`](crate::operation::get_data_access::GetDataAccessInput).
  233    289   
    pub fn builder() -> crate::operation::get_data_access::builders::GetDataAccessInputBuilder {
  234    290   
        crate::operation::get_data_access::builders::GetDataAccessInputBuilder::default()
  235    291   
    }

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/get_data_access/_get_data_access_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/get_job_tagging.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GetJobTagging`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetJobTagging;
    6      6   
impl GetJobTagging {
    7      7   
    /// Creates a new `GetJobTagging`
    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_job_tagging::GetJobTaggingInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_job_tagging::GetJobTaggingOutput::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_job_tagging::GetJobTaggingInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_job_tagging::GetJobTaggingOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_job_tagging::GetJobTaggingError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -118,122 +180,185 @@
  138    142   
                crate::operation::get_job_tagging::GetJobTaggingError,
  139    143   
            >::new());
  140    144   
  141    145   
        ::std::borrow::Cow::Owned(rcb)
  142    146   
    }
  143    147   
}
  144    148   
  145    149   
#[derive(Debug)]
  146    150   
struct GetJobTaggingResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetJobTaggingResponseDeserializer {
  148         -
    fn deserialize_nonstreaming(
         152  +
    fn deserialize_nonstreaming_with_config(
  149    153   
        &self,
  150    154   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         155  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    156   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    157   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153    158   
        let headers = response.headers();
  154    159   
        let body = response.body().bytes().expect("body loaded");
  155    160   
        #[allow(unused_mut)]
  156    161   
        let mut force_error = false;
  157    162   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  158    163   
        let parse_result = if !success && status != 200 || force_error {
  159    164   
            crate::protocol_serde::shape_get_job_tagging::de_get_job_tagging_http_error(status, headers, body)
  160    165   
        } else {

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/get_job_tagging/_get_job_tagging_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/get_job_tagging/_get_job_tagging_output.rs

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