AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12

Files changed:

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

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_access_grant.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 `CreateAccessGrant`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CreateAccessGrant;
    6      6   
impl CreateAccessGrant {
    7      7   
    /// Creates a new `CreateAccessGrant`
    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::create_access_grant::CreateAccessGrantInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::create_access_grant::CreateAccessGrantOutput::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::create_access_grant::CreateAccessGrantInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::create_access_grant::CreateAccessGrantOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::create_access_grant::CreateAccessGrantError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -118,122 +180,185 @@
  138    142   
                crate::operation::create_access_grant::CreateAccessGrantError,
  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 CreateAccessGrantResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateAccessGrantResponseDeserializer {
  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_create_access_grant::de_create_access_grant_http_error(status, headers, body)
  160    165   
        } else {

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

@@ -59,59 +300,366 @@
   79     79   
    "com.amazonaws.s3control.synthetic",
   80     80   
    "CreateAccessGrantInput",
   81     81   
);
   82     82   
static CREATEACCESSGRANTINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantInput$AccountId",
   85     85   
        "com.amazonaws.s3control.synthetic",
   86     86   
        "CreateAccessGrantInput",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "account_id",
          89  +
    "AccountId",
   90     90   
    0,
   91     91   
)
   92     92   
.with_host_label()
   93     93   
.with_http_header("x-amz-account-id");
   94     94   
static CREATEACCESSGRANTINPUT_MEMBER_ACCESS_GRANTS_LOCATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static(
   96     96   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantInput$AccessGrantsLocationId",
   97     97   
        "com.amazonaws.s3control.synthetic",
   98     98   
        "CreateAccessGrantInput",
   99     99   
    ),
  100    100   
    ::aws_smithy_schema::ShapeType::String,
  101         -
    "access_grants_location_id",
         101  +
    "AccessGrantsLocationId",
  102    102   
    1,
  103    103   
);
  104    104   
static CREATEACCESSGRANTINPUT_MEMBER_ACCESS_GRANTS_LOCATION_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static(
  106    106   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantInput$AccessGrantsLocationConfiguration",
  107    107   
        "com.amazonaws.s3control.synthetic",
  108    108   
        "CreateAccessGrantInput",
  109    109   
    ),
  110    110   
    ::aws_smithy_schema::ShapeType::Structure,
  111         -
    "access_grants_location_configuration",
         111  +
    "AccessGrantsLocationConfiguration",
  112    112   
    2,
  113    113   
);
  114    114   
static CREATEACCESSGRANTINPUT_MEMBER_GRANTEE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantInput$Grantee",
  117    117   
        "com.amazonaws.s3control.synthetic",
  118    118   
        "CreateAccessGrantInput",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::Structure,
  121         -
    "grantee",
         121  +
    "Grantee",
  122    122   
    3,
  123    123   
);
  124    124   
static CREATEACCESSGRANTINPUT_MEMBER_PERMISSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static(
  126    126   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantInput$Permission",
  127    127   
        "com.amazonaws.s3control.synthetic",
  128    128   
        "CreateAccessGrantInput",
  129    129   
    ),
  130    130   
    ::aws_smithy_schema::ShapeType::String,
  131         -
    "permission",
         131  +
    "Permission",
  132    132   
    4,
  133    133   
);
  134    134   
static CREATEACCESSGRANTINPUT_MEMBER_APPLICATION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantInput$ApplicationArn",
  137    137   
        "com.amazonaws.s3control.synthetic",
  138    138   
        "CreateAccessGrantInput",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::String,
  141         -
    "application_arn",
         141  +
    "ApplicationArn",
  142    142   
    5,
  143    143   
);
  144    144   
static CREATEACCESSGRANTINPUT_MEMBER_S3_PREFIX_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantInput$S3PrefixType",
  147    147   
        "com.amazonaws.s3control.synthetic",
  148    148   
        "CreateAccessGrantInput",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::String,
  151         -
    "s3_prefix_type",
         151  +
    "S3PrefixType",
  152    152   
    6,
  153    153   
);
  154    154   
static CREATEACCESSGRANTINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  155    155   
    ::aws_smithy_schema::ShapeId::from_static(
  156    156   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantInput$Tags",
  157    157   
        "com.amazonaws.s3control.synthetic",
  158    158   
        "CreateAccessGrantInput",
  159    159   
    ),
  160    160   
    ::aws_smithy_schema::ShapeType::List,
  161         -
    "tags",
         161  +
    "Tags",
  162    162   
    7,
  163    163   
);
  164    164   
static CREATEACCESSGRANTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  165    165   
    CREATEACCESSGRANTINPUT_SCHEMA_ID,
  166    166   
    ::aws_smithy_schema::ShapeType::Structure,
  167    167   
    &[
  168    168   
        &CREATEACCESSGRANTINPUT_MEMBER_ACCOUNT_ID,
  169    169   
        &CREATEACCESSGRANTINPUT_MEMBER_ACCESS_GRANTS_LOCATION_ID,
  170    170   
        &CREATEACCESSGRANTINPUT_MEMBER_ACCESS_GRANTS_LOCATION_CONFIGURATION,
  171    171   
        &CREATEACCESSGRANTINPUT_MEMBER_GRANTEE,
  172    172   
        &CREATEACCESSGRANTINPUT_MEMBER_PERMISSION,
  173    173   
        &CREATEACCESSGRANTINPUT_MEMBER_APPLICATION_ARN,
  174    174   
        &CREATEACCESSGRANTINPUT_MEMBER_S3_PREFIX_TYPE,
  175    175   
        &CREATEACCESSGRANTINPUT_MEMBER_TAGS,
  176    176   
    ],
  177         -
);
         177  +
)
         178  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
         179  +
    "POST",
         180  +
    "/v20180820/accessgrantsinstance/grant",
         181  +
    None,
         182  +
));
  178    183   
impl CreateAccessGrantInput {
  179    184   
    /// The schema for this shape.
  180    185   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEACCESSGRANTINPUT_SCHEMA;
  181    186   
}
  182    187   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateAccessGrantInput {
  183    188   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  184    189   
    fn serialize_members(
  185    190   
        &self,
  186    191   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  187    192   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  188    193   
        if let Some(ref val) = self.account_id {
  189    194   
            ser.write_string(&CREATEACCESSGRANTINPUT_MEMBER_ACCOUNT_ID, val)?;
  190    195   
        }
  191    196   
        if let Some(ref val) = self.access_grants_location_id {
  192    197   
            ser.write_string(&CREATEACCESSGRANTINPUT_MEMBER_ACCESS_GRANTS_LOCATION_ID, val)?;
  193    198   
        }
  194    199   
        if let Some(ref val) = self.access_grants_location_configuration {
  195    200   
            ser.write_struct(&CREATEACCESSGRANTINPUT_MEMBER_ACCESS_GRANTS_LOCATION_CONFIGURATION, val)?;
  196    201   
        }
  197    202   
        if let Some(ref val) = self.grantee {
  198    203   
            ser.write_struct(&CREATEACCESSGRANTINPUT_MEMBER_GRANTEE, val)?;
  199    204   
        }
  200    205   
        if let Some(ref val) = self.permission {
  201    206   
            ser.write_string(&CREATEACCESSGRANTINPUT_MEMBER_PERMISSION, val.as_str())?;
  202    207   
        }
  203    208   
        if let Some(ref val) = self.application_arn {
  204    209   
            ser.write_string(&CREATEACCESSGRANTINPUT_MEMBER_APPLICATION_ARN, val)?;
  205    210   
        }
  206    211   
        if let Some(ref val) = self.s3_prefix_type {
  207    212   
            ser.write_string(&CREATEACCESSGRANTINPUT_MEMBER_S3_PREFIX_TYPE, val.as_str())?;
  208    213   
        }
  209    214   
        if let Some(ref val) = self.tags {
  210    215   
            ser.write_list(
  211    216   
                &CREATEACCESSGRANTINPUT_MEMBER_TAGS,
  212    217   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  213    218   
                    for item in val {
  214    219   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  215    220   
                    }
  216    221   
                    Ok(())
  217    222   
                },
  218    223   
            )?;
  219    224   
        }
  220    225   
        Ok(())
  221    226   
    }
  222    227   
}
  223    228   
impl CreateAccessGrantInput {
  224    229   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  225         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  226         -
        deserializer: &mut D,
         230  +
    pub fn deserialize(
         231  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  227    232   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  228    233   
        #[allow(unused_variables, unused_mut)]
  229    234   
        let mut builder = Self::builder();
  230    235   
        #[allow(
  231    236   
            unused_variables,
  232    237   
            unreachable_code,
  233    238   
            clippy::single_match,
  234    239   
            clippy::match_single_binding,
  235    240   
            clippy::diverging_sub_expression
  236    241   
        )]
  237         -
        deserializer.read_struct(&CREATEACCESSGRANTINPUT_SCHEMA, (), |_, member, deser| {
         242  +
        deserializer.read_struct(&CREATEACCESSGRANTINPUT_SCHEMA, &mut |member, deser| {
  238    243   
            match member.member_index() {
  239    244   
                Some(0) => {
  240    245   
                    builder.account_id = Some(deser.read_string(member)?);
  241    246   
                }
  242    247   
                Some(1) => {
  243    248   
                    builder.access_grants_location_id = Some(deser.read_string(member)?);
  244    249   
                }
  245    250   
                Some(2) => {
  246    251   
                    builder.access_grants_location_configuration = Some(crate::types::AccessGrantsLocationConfiguration::deserialize(deser)?);
  247    252   
                }
  248    253   
                Some(3) => {
  249    254   
                    builder.grantee = Some(crate::types::Grantee::deserialize(deser)?);
  250    255   
                }
  251    256   
                Some(4) => {
  252    257   
                    builder.permission = Some(crate::types::Permission::from(deser.read_string(member)?.as_str()));
  253    258   
                }
  254    259   
                Some(5) => {
  255    260   
                    builder.application_arn = Some(deser.read_string(member)?);
  256    261   
                }
  257    262   
                Some(6) => {
  258    263   
                    builder.s3_prefix_type = Some(crate::types::S3PrefixType::from(deser.read_string(member)?.as_str()));
  259    264   
                }
  260    265   
                Some(7) => {
  261    266   
                    builder.tags = Some({
  262         -
                        let container = if let Some(cap) = deser.container_size() {
  263         -
                            Vec::with_capacity(cap)
  264         -
                        } else {
  265         -
                            Vec::new()
  266         -
                        };
  267         -
                        deser.read_list(member, container, |mut list, deser| {
  268         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  269         -
                            Ok(list)
  270         -
                        })?
         267  +
                        let mut container = Vec::new();
         268  +
                        deser.read_list(member, &mut |deser| {
         269  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         270  +
                            Ok(())
         271  +
                        })?;
         272  +
                        container
         273  +
                    });
         274  +
                }
         275  +
                _ => {}
         276  +
            }
         277  +
            Ok(())
         278  +
        })?;
         279  +
        builder.account_id = builder.account_id.or(Some(String::new()));
         280  +
        builder.access_grants_location_id = builder.access_grants_location_id.or(Some(String::new()));
         281  +
        builder
         282  +
            .build()
         283  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         284  +
    }
         285  +
}
         286  +
impl CreateAccessGrantInput {
         287  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         288  +
    /// Header-bound members are read directly from headers, avoiding runtime
         289  +
    /// member iteration overhead. Body members are read via the deserializer.
         290  +
    pub fn deserialize_with_response(
         291  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         292  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         293  +
        _status: u16,
         294  +
        _body: &[u8],
         295  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         296  +
        #[allow(unused_variables, unused_mut)]
         297  +
        let mut builder = Self::builder();
         298  +
        if let Some(val) = headers.get("x-amz-account-id") {
         299  +
            builder.account_id = Some(val.to_string());
         300  +
        }
         301  +
        #[allow(
         302  +
            unused_variables,
         303  +
            unreachable_code,
         304  +
            clippy::single_match,
         305  +
            clippy::match_single_binding,
         306  +
            clippy::diverging_sub_expression
         307  +
        )]
         308  +
        deserializer.read_struct(&CREATEACCESSGRANTINPUT_SCHEMA, &mut |member, deser| {
         309  +
            match member.member_index() {
         310  +
                Some(0) => { /* read from headers above */ }
         311  +
                Some(1) => {
         312  +
                    builder.access_grants_location_id = Some(deser.read_string(member)?);
         313  +
                }
         314  +
                Some(2) => {
         315  +
                    builder.access_grants_location_configuration = Some(crate::types::AccessGrantsLocationConfiguration::deserialize(deser)?);
         316  +
                }
         317  +
                Some(3) => {
         318  +
                    builder.grantee = Some(crate::types::Grantee::deserialize(deser)?);
         319  +
                }
         320  +
                Some(4) => {
         321  +
                    builder.permission = Some(crate::types::Permission::from(deser.read_string(member)?.as_str()));
         322  +
                }
         323  +
                Some(5) => {
         324  +
                    builder.application_arn = Some(deser.read_string(member)?);
         325  +
                }
         326  +
                Some(6) => {
         327  +
                    builder.s3_prefix_type = Some(crate::types::S3PrefixType::from(deser.read_string(member)?.as_str()));
         328  +
                }
         329  +
                Some(7) => {
         330  +
                    builder.tags = Some({
         331  +
                        let mut container = Vec::new();
         332  +
                        deser.read_list(member, &mut |deser| {
         333  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         334  +
                            Ok(())
         335  +
                        })?;
         336  +
                        container
  271    337   
                    });
  272    338   
                }
  273    339   
                _ => {}
  274    340   
            }
  275    341   
            Ok(())
  276    342   
        })?;
  277    343   
        builder
  278    344   
            .build()
  279    345   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  280    346   
    }

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

@@ -62,62 +274,343 @@
   82     82   
    "com.amazonaws.s3control.synthetic",
   83     83   
    "CreateAccessGrantOutput",
   84     84   
);
   85     85   
static CREATEACCESSGRANTOUTPUT_MEMBER_CREATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantOutput$CreatedAt",
   88     88   
        "com.amazonaws.s3control.synthetic",
   89     89   
        "CreateAccessGrantOutput",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::Timestamp,
   92         -
    "created_at",
          92  +
    "CreatedAt",
   93     93   
    0,
   94     94   
);
   95     95   
static CREATEACCESSGRANTOUTPUT_MEMBER_ACCESS_GRANT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantOutput$AccessGrantId",
   98     98   
        "com.amazonaws.s3control.synthetic",
   99     99   
        "CreateAccessGrantOutput",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::String,
  102         -
    "access_grant_id",
         102  +
    "AccessGrantId",
  103    103   
    1,
  104    104   
);
  105    105   
static CREATEACCESSGRANTOUTPUT_MEMBER_ACCESS_GRANT_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static(
  107    107   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantOutput$AccessGrantArn",
  108    108   
        "com.amazonaws.s3control.synthetic",
  109    109   
        "CreateAccessGrantOutput",
  110    110   
    ),
  111    111   
    ::aws_smithy_schema::ShapeType::String,
  112         -
    "access_grant_arn",
         112  +
    "AccessGrantArn",
  113    113   
    2,
  114    114   
);
  115    115   
static CREATEACCESSGRANTOUTPUT_MEMBER_GRANTEE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static(
  117    117   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantOutput$Grantee",
  118    118   
        "com.amazonaws.s3control.synthetic",
  119    119   
        "CreateAccessGrantOutput",
  120    120   
    ),
  121    121   
    ::aws_smithy_schema::ShapeType::Structure,
  122         -
    "grantee",
         122  +
    "Grantee",
  123    123   
    3,
  124    124   
);
  125    125   
static CREATEACCESSGRANTOUTPUT_MEMBER_ACCESS_GRANTS_LOCATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantOutput$AccessGrantsLocationId",
  128    128   
        "com.amazonaws.s3control.synthetic",
  129    129   
        "CreateAccessGrantOutput",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::String,
  132         -
    "access_grants_location_id",
         132  +
    "AccessGrantsLocationId",
  133    133   
    4,
  134    134   
);
  135    135   
static CREATEACCESSGRANTOUTPUT_MEMBER_ACCESS_GRANTS_LOCATION_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static(
  137    137   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantOutput$AccessGrantsLocationConfiguration",
  138    138   
        "com.amazonaws.s3control.synthetic",
  139    139   
        "CreateAccessGrantOutput",
  140    140   
    ),
  141    141   
    ::aws_smithy_schema::ShapeType::Structure,
  142         -
    "access_grants_location_configuration",
         142  +
    "AccessGrantsLocationConfiguration",
  143    143   
    5,
  144    144   
);
  145    145   
static CREATEACCESSGRANTOUTPUT_MEMBER_PERMISSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static(
  147    147   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantOutput$Permission",
  148    148   
        "com.amazonaws.s3control.synthetic",
  149    149   
        "CreateAccessGrantOutput",
  150    150   
    ),
  151    151   
    ::aws_smithy_schema::ShapeType::String,
  152         -
    "permission",
         152  +
    "Permission",
  153    153   
    6,
  154    154   
);
  155    155   
static CREATEACCESSGRANTOUTPUT_MEMBER_APPLICATION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  156    156   
    ::aws_smithy_schema::ShapeId::from_static(
  157    157   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantOutput$ApplicationArn",
  158    158   
        "com.amazonaws.s3control.synthetic",
  159    159   
        "CreateAccessGrantOutput",
  160    160   
    ),
  161    161   
    ::aws_smithy_schema::ShapeType::String,
  162         -
    "application_arn",
         162  +
    "ApplicationArn",
  163    163   
    7,
  164    164   
);
  165    165   
static CREATEACCESSGRANTOUTPUT_MEMBER_GRANT_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  166    166   
    ::aws_smithy_schema::ShapeId::from_static(
  167    167   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantOutput$GrantScope",
  168    168   
        "com.amazonaws.s3control.synthetic",
  169    169   
        "CreateAccessGrantOutput",
  170    170   
    ),
  171    171   
    ::aws_smithy_schema::ShapeType::String,
  172         -
    "grant_scope",
         172  +
    "GrantScope",
  173    173   
    8,
  174    174   
);
         175  +
static CREATEACCESSGRANTOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         176  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         177  +
    ::aws_smithy_schema::ShapeType::String,
         178  +
    "request_id",
         179  +
    9,
         180  +
)
         181  +
.with_http_header("x-amzn-requestid");
  175    182   
static CREATEACCESSGRANTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  176    183   
    CREATEACCESSGRANTOUTPUT_SCHEMA_ID,
  177    184   
    ::aws_smithy_schema::ShapeType::Structure,
  178    185   
    &[
  179    186   
        &CREATEACCESSGRANTOUTPUT_MEMBER_CREATED_AT,
  180    187   
        &CREATEACCESSGRANTOUTPUT_MEMBER_ACCESS_GRANT_ID,
  181    188   
        &CREATEACCESSGRANTOUTPUT_MEMBER_ACCESS_GRANT_ARN,
  182    189   
        &CREATEACCESSGRANTOUTPUT_MEMBER_GRANTEE,
  183    190   
        &CREATEACCESSGRANTOUTPUT_MEMBER_ACCESS_GRANTS_LOCATION_ID,
  184    191   
        &CREATEACCESSGRANTOUTPUT_MEMBER_ACCESS_GRANTS_LOCATION_CONFIGURATION,
  185    192   
        &CREATEACCESSGRANTOUTPUT_MEMBER_PERMISSION,
  186    193   
        &CREATEACCESSGRANTOUTPUT_MEMBER_APPLICATION_ARN,
  187    194   
        &CREATEACCESSGRANTOUTPUT_MEMBER_GRANT_SCOPE,
         195  +
        &CREATEACCESSGRANTOUTPUT_MEMBER__REQUEST_ID,
  188    196   
    ],
  189    197   
);
  190    198   
impl CreateAccessGrantOutput {
  191    199   
    /// The schema for this shape.
  192    200   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEACCESSGRANTOUTPUT_SCHEMA;
  193    201   
}
  194    202   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateAccessGrantOutput {
  195    203   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  196    204   
    fn serialize_members(
  197    205   
        &self,
  198    206   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  199    207   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  200    208   
        if let Some(ref val) = self.created_at {
  201    209   
            ser.write_timestamp(&CREATEACCESSGRANTOUTPUT_MEMBER_CREATED_AT, val)?;
  202    210   
        }
  203    211   
        if let Some(ref val) = self.access_grant_id {
  204    212   
            ser.write_string(&CREATEACCESSGRANTOUTPUT_MEMBER_ACCESS_GRANT_ID, val)?;
  205    213   
        }
  206    214   
        if let Some(ref val) = self.access_grant_arn {
  207    215   
            ser.write_string(&CREATEACCESSGRANTOUTPUT_MEMBER_ACCESS_GRANT_ARN, val)?;
  208    216   
        }
  209    217   
        if let Some(ref val) = self.grantee {
  210    218   
            ser.write_struct(&CREATEACCESSGRANTOUTPUT_MEMBER_GRANTEE, val)?;
  211    219   
        }
  212    220   
        if let Some(ref val) = self.access_grants_location_id {
  213    221   
            ser.write_string(&CREATEACCESSGRANTOUTPUT_MEMBER_ACCESS_GRANTS_LOCATION_ID, val)?;
  214    222   
        }
  215    223   
        if let Some(ref val) = self.access_grants_location_configuration {
  216    224   
            ser.write_struct(&CREATEACCESSGRANTOUTPUT_MEMBER_ACCESS_GRANTS_LOCATION_CONFIGURATION, val)?;
  217    225   
        }
  218    226   
        if let Some(ref val) = self.permission {
  219    227   
            ser.write_string(&CREATEACCESSGRANTOUTPUT_MEMBER_PERMISSION, val.as_str())?;
  220    228   
        }
  221    229   
        if let Some(ref val) = self.application_arn {
  222    230   
            ser.write_string(&CREATEACCESSGRANTOUTPUT_MEMBER_APPLICATION_ARN, val)?;
  223    231   
        }
  224    232   
        if let Some(ref val) = self.grant_scope {
  225    233   
            ser.write_string(&CREATEACCESSGRANTOUTPUT_MEMBER_GRANT_SCOPE, val)?;
  226    234   
        }
  227    235   
        Ok(())
  228    236   
    }
  229    237   
}
  230    238   
impl CreateAccessGrantOutput {
  231    239   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  232         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  233         -
        deserializer: &mut D,
         240  +
    pub fn deserialize(
         241  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  234    242   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  235    243   
        #[allow(unused_variables, unused_mut)]
  236    244   
        let mut builder = Self::builder();
  237    245   
        #[allow(
  238    246   
            unused_variables,
  239    247   
            unreachable_code,
  240    248   
            clippy::single_match,
  241    249   
            clippy::match_single_binding,
  242    250   
            clippy::diverging_sub_expression
  243    251   
        )]
  244         -
        deserializer.read_struct(&CREATEACCESSGRANTOUTPUT_SCHEMA, (), |_, member, deser| {
         252  +
        deserializer.read_struct(&CREATEACCESSGRANTOUTPUT_SCHEMA, &mut |member, deser| {
         253  +
            match member.member_index() {
         254  +
                Some(0) => {
         255  +
                    builder.created_at = Some(deser.read_timestamp(member)?);
         256  +
                }
         257  +
                Some(1) => {
         258  +
                    builder.access_grant_id = Some(deser.read_string(member)?);
         259  +
                }
         260  +
                Some(2) => {
         261  +
                    builder.access_grant_arn = Some(deser.read_string(member)?);
         262  +
                }
         263  +
                Some(3) => {
         264  +
                    builder.grantee = Some(crate::types::Grantee::deserialize(deser)?);
         265  +
                }
         266  +
                Some(4) => {
         267  +
                    builder.access_grants_location_id = Some(deser.read_string(member)?);
         268  +
                }
         269  +
                Some(5) => {
         270  +
                    builder.access_grants_location_configuration = Some(crate::types::AccessGrantsLocationConfiguration::deserialize(deser)?);
         271  +
                }
         272  +
                Some(6) => {
         273  +
                    builder.permission = Some(crate::types::Permission::from(deser.read_string(member)?.as_str()));
         274  +
                }
         275  +
                Some(7) => {
         276  +
                    builder.application_arn = Some(deser.read_string(member)?);
         277  +
                }
         278  +
                Some(8) => {
         279  +
                    builder.grant_scope = Some(deser.read_string(member)?);
         280  +
                }
         281  +
                Some(9) => {
         282  +
                    builder._request_id = Some(deser.read_string(member)?);
         283  +
                }
         284  +
                _ => {}
         285  +
            }
         286  +
            Ok(())
         287  +
        })?;
         288  +
        Ok(builder.build())
         289  +
    }
         290  +
}
         291  +
impl CreateAccessGrantOutput {
         292  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         293  +
    /// Header-bound members are read directly from headers, avoiding runtime
         294  +
    /// member iteration overhead. Body members are read via the deserializer.
         295  +
    pub fn deserialize_with_response(
         296  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         297  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         298  +
        _status: u16,
         299  +
        _body: &[u8],
         300  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         301  +
        #[allow(unused_variables, unused_mut)]
         302  +
        let mut builder = Self::builder();
         303  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         304  +
            builder._request_id = Some(val.to_string());
         305  +
        }
         306  +
        #[allow(
         307  +
            unused_variables,
         308  +
            unreachable_code,
         309  +
            clippy::single_match,
         310  +
            clippy::match_single_binding,
         311  +
            clippy::diverging_sub_expression
         312  +
        )]
         313  +
        deserializer.read_struct(&CREATEACCESSGRANTOUTPUT_SCHEMA, &mut |member, deser| {
  245    314   
            match member.member_index() {
  246    315   
                Some(0) => {
  247    316   
                    builder.created_at = Some(deser.read_timestamp(member)?);
  248    317   
                }
  249    318   
                Some(1) => {
  250    319   
                    builder.access_grant_id = Some(deser.read_string(member)?);
  251    320   
                }
  252    321   
                Some(2) => {
  253    322   
                    builder.access_grant_arn = Some(deser.read_string(member)?);
  254    323   
                }

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

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

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

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

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

@@ -30,30 +200,260 @@
   50     50   
    "com.amazonaws.s3control.synthetic",
   51     51   
    "CreateAccessGrantsInstanceOutput",
   52     52   
);
   53     53   
static CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_CREATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsInstanceOutput$CreatedAt",
   56     56   
        "com.amazonaws.s3control.synthetic",
   57     57   
        "CreateAccessGrantsInstanceOutput",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Timestamp,
   60         -
    "created_at",
          60  +
    "CreatedAt",
   61     61   
    0,
   62     62   
);
   63     63   
static CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_ACCESS_GRANTS_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsInstanceOutput$AccessGrantsInstanceId",
   66     66   
        "com.amazonaws.s3control.synthetic",
   67     67   
        "CreateAccessGrantsInstanceOutput",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "access_grants_instance_id",
          70  +
    "AccessGrantsInstanceId",
   71     71   
    1,
   72     72   
);
   73     73   
static CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_ACCESS_GRANTS_INSTANCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsInstanceOutput$AccessGrantsInstanceArn",
   76     76   
        "com.amazonaws.s3control.synthetic",
   77     77   
        "CreateAccessGrantsInstanceOutput",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "access_grants_instance_arn",
          80  +
    "AccessGrantsInstanceArn",
   81     81   
    2,
   82     82   
);
   83     83   
static CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_IDENTITY_CENTER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsInstanceOutput$IdentityCenterArn",
   86     86   
        "com.amazonaws.s3control.synthetic",
   87     87   
        "CreateAccessGrantsInstanceOutput",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "identity_center_arn",
          90  +
    "IdentityCenterArn",
   91     91   
    3,
   92     92   
);
   93     93   
static CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_IDENTITY_CENTER_INSTANCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsInstanceOutput$IdentityCenterInstanceArn",
   96     96   
        "com.amazonaws.s3control.synthetic",
   97     97   
        "CreateAccessGrantsInstanceOutput",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "identity_center_instance_arn",
         100  +
    "IdentityCenterInstanceArn",
  101    101   
    4,
  102    102   
);
  103    103   
static CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_IDENTITY_CENTER_APPLICATION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsInstanceOutput$IdentityCenterApplicationArn",
  106    106   
        "com.amazonaws.s3control.synthetic",
  107    107   
        "CreateAccessGrantsInstanceOutput",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::String,
  110         -
    "identity_center_application_arn",
         110  +
    "IdentityCenterApplicationArn",
  111    111   
    5,
  112    112   
);
         113  +
static CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         114  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         115  +
    ::aws_smithy_schema::ShapeType::String,
         116  +
    "request_id",
         117  +
    6,
         118  +
)
         119  +
.with_http_header("x-amzn-requestid");
  113    120   
static CREATEACCESSGRANTSINSTANCEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  114    121   
    CREATEACCESSGRANTSINSTANCEOUTPUT_SCHEMA_ID,
  115    122   
    ::aws_smithy_schema::ShapeType::Structure,
  116    123   
    &[
  117    124   
        &CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_CREATED_AT,
  118    125   
        &CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_ACCESS_GRANTS_INSTANCE_ID,
  119    126   
        &CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_ACCESS_GRANTS_INSTANCE_ARN,
  120    127   
        &CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_IDENTITY_CENTER_ARN,
  121    128   
        &CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_IDENTITY_CENTER_INSTANCE_ARN,
  122    129   
        &CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_IDENTITY_CENTER_APPLICATION_ARN,
         130  +
        &CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER__REQUEST_ID,
  123    131   
    ],
  124    132   
);
  125    133   
impl CreateAccessGrantsInstanceOutput {
  126    134   
    /// The schema for this shape.
  127    135   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEACCESSGRANTSINSTANCEOUTPUT_SCHEMA;
  128    136   
}
  129    137   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateAccessGrantsInstanceOutput {
  130    138   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  131    139   
    fn serialize_members(
  132    140   
        &self,
  133    141   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  134    142   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  135    143   
        if let Some(ref val) = self.created_at {
  136    144   
            ser.write_timestamp(&CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_CREATED_AT, val)?;
  137    145   
        }
  138    146   
        if let Some(ref val) = self.access_grants_instance_id {
  139    147   
            ser.write_string(&CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_ACCESS_GRANTS_INSTANCE_ID, val)?;
  140    148   
        }
  141    149   
        if let Some(ref val) = self.access_grants_instance_arn {
  142    150   
            ser.write_string(&CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_ACCESS_GRANTS_INSTANCE_ARN, val)?;
  143    151   
        }
  144    152   
        if let Some(ref val) = self.identity_center_arn {
  145    153   
            ser.write_string(&CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_IDENTITY_CENTER_ARN, val)?;
  146    154   
        }
  147    155   
        if let Some(ref val) = self.identity_center_instance_arn {
  148    156   
            ser.write_string(&CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_IDENTITY_CENTER_INSTANCE_ARN, val)?;
  149    157   
        }
  150    158   
        if let Some(ref val) = self.identity_center_application_arn {
  151    159   
            ser.write_string(&CREATEACCESSGRANTSINSTANCEOUTPUT_MEMBER_IDENTITY_CENTER_APPLICATION_ARN, val)?;
  152    160   
        }
  153    161   
        Ok(())
  154    162   
    }
  155    163   
}
  156    164   
impl CreateAccessGrantsInstanceOutput {
  157    165   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  158         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  159         -
        deserializer: &mut D,
         166  +
    pub fn deserialize(
         167  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         168  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         169  +
        #[allow(unused_variables, unused_mut)]
         170  +
        let mut builder = Self::builder();
         171  +
        #[allow(
         172  +
            unused_variables,
         173  +
            unreachable_code,
         174  +
            clippy::single_match,
         175  +
            clippy::match_single_binding,
         176  +
            clippy::diverging_sub_expression
         177  +
        )]
         178  +
        deserializer.read_struct(&CREATEACCESSGRANTSINSTANCEOUTPUT_SCHEMA, &mut |member, deser| {
         179  +
            match member.member_index() {
         180  +
                Some(0) => {
         181  +
                    builder.created_at = Some(deser.read_timestamp(member)?);
         182  +
                }
         183  +
                Some(1) => {
         184  +
                    builder.access_grants_instance_id = Some(deser.read_string(member)?);
         185  +
                }
         186  +
                Some(2) => {
         187  +
                    builder.access_grants_instance_arn = Some(deser.read_string(member)?);
         188  +
                }
         189  +
                Some(3) => {
         190  +
                    builder.identity_center_arn = Some(deser.read_string(member)?);
         191  +
                }
         192  +
                Some(4) => {
         193  +
                    builder.identity_center_instance_arn = Some(deser.read_string(member)?);
         194  +
                }
         195  +
                Some(5) => {
         196  +
                    builder.identity_center_application_arn = Some(deser.read_string(member)?);
         197  +
                }
         198  +
                Some(6) => {
         199  +
                    builder._request_id = Some(deser.read_string(member)?);
         200  +
                }
         201  +
                _ => {}
         202  +
            }
         203  +
            Ok(())
         204  +
        })?;
         205  +
        Ok(builder.build())
         206  +
    }
         207  +
}
         208  +
impl CreateAccessGrantsInstanceOutput {
         209  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         210  +
    /// Header-bound members are read directly from headers, avoiding runtime
         211  +
    /// member iteration overhead. Body members are read via the deserializer.
         212  +
    pub fn deserialize_with_response(
         213  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         214  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         215  +
        _status: u16,
         216  +
        _body: &[u8],
  160    217   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  161    218   
        #[allow(unused_variables, unused_mut)]
  162    219   
        let mut builder = Self::builder();
         220  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         221  +
            builder._request_id = Some(val.to_string());
         222  +
        }
  163    223   
        #[allow(
  164    224   
            unused_variables,
  165    225   
            unreachable_code,
  166    226   
            clippy::single_match,
  167    227   
            clippy::match_single_binding,
  168    228   
            clippy::diverging_sub_expression
  169    229   
        )]
  170         -
        deserializer.read_struct(&CREATEACCESSGRANTSINSTANCEOUTPUT_SCHEMA, (), |_, member, deser| {
         230  +
        deserializer.read_struct(&CREATEACCESSGRANTSINSTANCEOUTPUT_SCHEMA, &mut |member, deser| {
  171    231   
            match member.member_index() {
  172    232   
                Some(0) => {
  173    233   
                    builder.created_at = Some(deser.read_timestamp(member)?);
  174    234   
                }
  175    235   
                Some(1) => {
  176    236   
                    builder.access_grants_instance_id = Some(deser.read_string(member)?);
  177    237   
                }
  178    238   
                Some(2) => {
  179    239   
                    builder.access_grants_instance_arn = Some(deser.read_string(member)?);
  180    240   
                }

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

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

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

@@ -23,23 +196,251 @@
   43     43   
    "com.amazonaws.s3control.synthetic",
   44     44   
    "CreateAccessGrantsLocationInput",
   45     45   
);
   46     46   
static CREATEACCESSGRANTSLOCATIONINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   47     47   
    ::aws_smithy_schema::ShapeId::from_static(
   48     48   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsLocationInput$AccountId",
   49     49   
        "com.amazonaws.s3control.synthetic",
   50     50   
        "CreateAccessGrantsLocationInput",
   51     51   
    ),
   52     52   
    ::aws_smithy_schema::ShapeType::String,
   53         -
    "account_id",
          53  +
    "AccountId",
   54     54   
    0,
   55     55   
)
   56     56   
.with_host_label()
   57     57   
.with_http_header("x-amz-account-id");
   58     58   
static CREATEACCESSGRANTSLOCATIONINPUT_MEMBER_LOCATION_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static(
   60     60   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsLocationInput$LocationScope",
   61     61   
        "com.amazonaws.s3control.synthetic",
   62     62   
        "CreateAccessGrantsLocationInput",
   63     63   
    ),
   64     64   
    ::aws_smithy_schema::ShapeType::String,
   65         -
    "location_scope",
          65  +
    "LocationScope",
   66     66   
    1,
   67     67   
);
   68     68   
static CREATEACCESSGRANTSLOCATIONINPUT_MEMBER_IAM_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsLocationInput$IAMRoleArn",
   71     71   
        "com.amazonaws.s3control.synthetic",
   72     72   
        "CreateAccessGrantsLocationInput",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "iam_role_arn",
          75  +
    "IAMRoleArn",
   76     76   
    2,
   77     77   
);
   78     78   
static CREATEACCESSGRANTSLOCATIONINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsLocationInput$Tags",
   81     81   
        "com.amazonaws.s3control.synthetic",
   82     82   
        "CreateAccessGrantsLocationInput",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::List,
   85         -
    "tags",
          85  +
    "Tags",
   86     86   
    3,
   87     87   
);
   88     88   
static CREATEACCESSGRANTSLOCATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   89     89   
    CREATEACCESSGRANTSLOCATIONINPUT_SCHEMA_ID,
   90     90   
    ::aws_smithy_schema::ShapeType::Structure,
   91     91   
    &[
   92     92   
        &CREATEACCESSGRANTSLOCATIONINPUT_MEMBER_ACCOUNT_ID,
   93     93   
        &CREATEACCESSGRANTSLOCATIONINPUT_MEMBER_LOCATION_SCOPE,
   94     94   
        &CREATEACCESSGRANTSLOCATIONINPUT_MEMBER_IAM_ROLE_ARN,
   95     95   
        &CREATEACCESSGRANTSLOCATIONINPUT_MEMBER_TAGS,
   96     96   
    ],
   97         -
);
          97  +
)
          98  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
          99  +
    "POST",
         100  +
    "/v20180820/accessgrantsinstance/location",
         101  +
    None,
         102  +
));
   98    103   
impl CreateAccessGrantsLocationInput {
   99    104   
    /// The schema for this shape.
  100    105   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEACCESSGRANTSLOCATIONINPUT_SCHEMA;
  101    106   
}
  102    107   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateAccessGrantsLocationInput {
  103    108   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  104    109   
    fn serialize_members(
  105    110   
        &self,
  106    111   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  107    112   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  108    113   
        if let Some(ref val) = self.account_id {
  109    114   
            ser.write_string(&CREATEACCESSGRANTSLOCATIONINPUT_MEMBER_ACCOUNT_ID, val)?;
  110    115   
        }
  111    116   
        if let Some(ref val) = self.location_scope {
  112    117   
            ser.write_string(&CREATEACCESSGRANTSLOCATIONINPUT_MEMBER_LOCATION_SCOPE, val)?;
  113    118   
        }
  114    119   
        if let Some(ref val) = self.iam_role_arn {
  115    120   
            ser.write_string(&CREATEACCESSGRANTSLOCATIONINPUT_MEMBER_IAM_ROLE_ARN, val)?;
  116    121   
        }
  117    122   
        if let Some(ref val) = self.tags {
  118    123   
            ser.write_list(
  119    124   
                &CREATEACCESSGRANTSLOCATIONINPUT_MEMBER_TAGS,
  120    125   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  121    126   
                    for item in val {
  122    127   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  123    128   
                    }
  124    129   
                    Ok(())
  125    130   
                },
  126    131   
            )?;
  127    132   
        }
  128    133   
        Ok(())
  129    134   
    }
  130    135   
}
  131    136   
impl CreateAccessGrantsLocationInput {
  132    137   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  133         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  134         -
        deserializer: &mut D,
         138  +
    pub fn deserialize(
         139  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  135    140   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  136    141   
        #[allow(unused_variables, unused_mut)]
  137    142   
        let mut builder = Self::builder();
  138    143   
        #[allow(
  139    144   
            unused_variables,
  140    145   
            unreachable_code,
  141    146   
            clippy::single_match,
  142    147   
            clippy::match_single_binding,
  143    148   
            clippy::diverging_sub_expression
  144    149   
        )]
  145         -
        deserializer.read_struct(&CREATEACCESSGRANTSLOCATIONINPUT_SCHEMA, (), |_, member, deser| {
         150  +
        deserializer.read_struct(&CREATEACCESSGRANTSLOCATIONINPUT_SCHEMA, &mut |member, deser| {
  146    151   
            match member.member_index() {
  147    152   
                Some(0) => {
  148    153   
                    builder.account_id = Some(deser.read_string(member)?);
  149    154   
                }
  150    155   
                Some(1) => {
  151    156   
                    builder.location_scope = Some(deser.read_string(member)?);
  152    157   
                }
  153    158   
                Some(2) => {
  154    159   
                    builder.iam_role_arn = Some(deser.read_string(member)?);
  155    160   
                }
  156    161   
                Some(3) => {
  157    162   
                    builder.tags = Some({
  158         -
                        let container = if let Some(cap) = deser.container_size() {
  159         -
                            Vec::with_capacity(cap)
  160         -
                        } else {
  161         -
                            Vec::new()
  162         -
                        };
  163         -
                        deser.read_list(member, container, |mut list, deser| {
  164         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  165         -
                            Ok(list)
  166         -
                        })?
         163  +
                        let mut container = Vec::new();
         164  +
                        deser.read_list(member, &mut |deser| {
         165  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         166  +
                            Ok(())
         167  +
                        })?;
         168  +
                        container
         169  +
                    });
         170  +
                }
         171  +
                _ => {}
         172  +
            }
         173  +
            Ok(())
         174  +
        })?;
         175  +
        builder.account_id = builder.account_id.or(Some(String::new()));
         176  +
        builder.location_scope = builder.location_scope.or(Some(String::new()));
         177  +
        builder.iam_role_arn = builder.iam_role_arn.or(Some(String::new()));
         178  +
        builder
         179  +
            .build()
         180  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         181  +
    }
         182  +
}
         183  +
impl CreateAccessGrantsLocationInput {
         184  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         185  +
    /// Header-bound members are read directly from headers, avoiding runtime
         186  +
    /// member iteration overhead. Body members are read via the deserializer.
         187  +
    pub fn deserialize_with_response(
         188  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         189  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         190  +
        _status: u16,
         191  +
        _body: &[u8],
         192  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         193  +
        #[allow(unused_variables, unused_mut)]
         194  +
        let mut builder = Self::builder();
         195  +
        if let Some(val) = headers.get("x-amz-account-id") {
         196  +
            builder.account_id = Some(val.to_string());
         197  +
        }
         198  +
        #[allow(
         199  +
            unused_variables,
         200  +
            unreachable_code,
         201  +
            clippy::single_match,
         202  +
            clippy::match_single_binding,
         203  +
            clippy::diverging_sub_expression
         204  +
        )]
         205  +
        deserializer.read_struct(&CREATEACCESSGRANTSLOCATIONINPUT_SCHEMA, &mut |member, deser| {
         206  +
            match member.member_index() {
         207  +
                Some(0) => { /* read from headers above */ }
         208  +
                Some(1) => {
         209  +
                    builder.location_scope = Some(deser.read_string(member)?);
         210  +
                }
         211  +
                Some(2) => {
         212  +
                    builder.iam_role_arn = Some(deser.read_string(member)?);
         213  +
                }
         214  +
                Some(3) => {
         215  +
                    builder.tags = Some({
         216  +
                        let mut container = Vec::new();
         217  +
                        deser.read_list(member, &mut |deser| {
         218  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         219  +
                            Ok(())
         220  +
                        })?;
         221  +
                        container
  167    222   
                    });
  168    223   
                }
  169    224   
                _ => {}
  170    225   
            }
  171    226   
            Ok(())
  172    227   
        })?;
  173    228   
        builder
  174    229   
            .build()
  175    230   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  176    231   
    }

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

@@ -22,22 +178,235 @@
   42     42   
    "com.amazonaws.s3control.synthetic",
   43     43   
    "CreateAccessGrantsLocationOutput",
   44     44   
);
   45     45   
static CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_CREATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static(
   47     47   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsLocationOutput$CreatedAt",
   48     48   
        "com.amazonaws.s3control.synthetic",
   49     49   
        "CreateAccessGrantsLocationOutput",
   50     50   
    ),
   51     51   
    ::aws_smithy_schema::ShapeType::Timestamp,
   52         -
    "created_at",
          52  +
    "CreatedAt",
   53     53   
    0,
   54     54   
);
   55     55   
static CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_ACCESS_GRANTS_LOCATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsLocationOutput$AccessGrantsLocationId",
   58     58   
        "com.amazonaws.s3control.synthetic",
   59     59   
        "CreateAccessGrantsLocationOutput",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::String,
   62         -
    "access_grants_location_id",
          62  +
    "AccessGrantsLocationId",
   63     63   
    1,
   64     64   
);
   65     65   
static CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_ACCESS_GRANTS_LOCATION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static(
   67     67   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsLocationOutput$AccessGrantsLocationArn",
   68     68   
        "com.amazonaws.s3control.synthetic",
   69     69   
        "CreateAccessGrantsLocationOutput",
   70     70   
    ),
   71     71   
    ::aws_smithy_schema::ShapeType::String,
   72         -
    "access_grants_location_arn",
          72  +
    "AccessGrantsLocationArn",
   73     73   
    2,
   74     74   
);
   75     75   
static CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_LOCATION_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static(
   77     77   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsLocationOutput$LocationScope",
   78     78   
        "com.amazonaws.s3control.synthetic",
   79     79   
        "CreateAccessGrantsLocationOutput",
   80     80   
    ),
   81     81   
    ::aws_smithy_schema::ShapeType::String,
   82         -
    "location_scope",
          82  +
    "LocationScope",
   83     83   
    3,
   84     84   
);
   85     85   
static CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_IAM_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "com.amazonaws.s3control.synthetic#CreateAccessGrantsLocationOutput$IAMRoleArn",
   88     88   
        "com.amazonaws.s3control.synthetic",
   89     89   
        "CreateAccessGrantsLocationOutput",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::String,
   92         -
    "iam_role_arn",
          92  +
    "IAMRoleArn",
   93     93   
    4,
   94     94   
);
          95  +
static CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          96  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          97  +
    ::aws_smithy_schema::ShapeType::String,
          98  +
    "request_id",
          99  +
    5,
         100  +
)
         101  +
.with_http_header("x-amzn-requestid");
   95    102   
static CREATEACCESSGRANTSLOCATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   96    103   
    CREATEACCESSGRANTSLOCATIONOUTPUT_SCHEMA_ID,
   97    104   
    ::aws_smithy_schema::ShapeType::Structure,
   98    105   
    &[
   99    106   
        &CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_CREATED_AT,
  100    107   
        &CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_ACCESS_GRANTS_LOCATION_ID,
  101    108   
        &CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_ACCESS_GRANTS_LOCATION_ARN,
  102    109   
        &CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_LOCATION_SCOPE,
  103    110   
        &CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_IAM_ROLE_ARN,
         111  +
        &CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER__REQUEST_ID,
  104    112   
    ],
  105    113   
);
  106    114   
impl CreateAccessGrantsLocationOutput {
  107    115   
    /// The schema for this shape.
  108    116   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEACCESSGRANTSLOCATIONOUTPUT_SCHEMA;
  109    117   
}
  110    118   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateAccessGrantsLocationOutput {
  111    119   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  112    120   
    fn serialize_members(
  113    121   
        &self,
  114    122   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  115    123   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  116    124   
        if let Some(ref val) = self.created_at {
  117    125   
            ser.write_timestamp(&CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_CREATED_AT, val)?;
  118    126   
        }
  119    127   
        if let Some(ref val) = self.access_grants_location_id {
  120    128   
            ser.write_string(&CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_ACCESS_GRANTS_LOCATION_ID, val)?;
  121    129   
        }
  122    130   
        if let Some(ref val) = self.access_grants_location_arn {
  123    131   
            ser.write_string(&CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_ACCESS_GRANTS_LOCATION_ARN, val)?;
  124    132   
        }
  125    133   
        if let Some(ref val) = self.location_scope {
  126    134   
            ser.write_string(&CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_LOCATION_SCOPE, val)?;
  127    135   
        }
  128    136   
        if let Some(ref val) = self.iam_role_arn {
  129    137   
            ser.write_string(&CREATEACCESSGRANTSLOCATIONOUTPUT_MEMBER_IAM_ROLE_ARN, val)?;
  130    138   
        }
  131    139   
        Ok(())
  132    140   
    }
  133    141   
}
  134    142   
impl CreateAccessGrantsLocationOutput {
  135    143   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  136         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  137         -
        deserializer: &mut D,
         144  +
    pub fn deserialize(
         145  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  138    146   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  139    147   
        #[allow(unused_variables, unused_mut)]
  140    148   
        let mut builder = Self::builder();
  141    149   
        #[allow(
  142    150   
            unused_variables,
  143    151   
            unreachable_code,
  144    152   
            clippy::single_match,
  145    153   
            clippy::match_single_binding,
  146    154   
            clippy::diverging_sub_expression
  147    155   
        )]
  148         -
        deserializer.read_struct(&CREATEACCESSGRANTSLOCATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         156  +
        deserializer.read_struct(&CREATEACCESSGRANTSLOCATIONOUTPUT_SCHEMA, &mut |member, deser| {
         157  +
            match member.member_index() {
         158  +
                Some(0) => {
         159  +
                    builder.created_at = Some(deser.read_timestamp(member)?);
         160  +
                }
         161  +
                Some(1) => {
         162  +
                    builder.access_grants_location_id = Some(deser.read_string(member)?);
         163  +
                }
         164  +
                Some(2) => {
         165  +
                    builder.access_grants_location_arn = Some(deser.read_string(member)?);
         166  +
                }
         167  +
                Some(3) => {
         168  +
                    builder.location_scope = Some(deser.read_string(member)?);
         169  +
                }
         170  +
                Some(4) => {
         171  +
                    builder.iam_role_arn = Some(deser.read_string(member)?);
         172  +
                }
         173  +
                Some(5) => {
         174  +
                    builder._request_id = Some(deser.read_string(member)?);
         175  +
                }
         176  +
                _ => {}
         177  +
            }
         178  +
            Ok(())
         179  +
        })?;
         180  +
        Ok(builder.build())
         181  +
    }
         182  +
}
         183  +
impl CreateAccessGrantsLocationOutput {
         184  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         185  +
    /// Header-bound members are read directly from headers, avoiding runtime
         186  +
    /// member iteration overhead. Body members are read via the deserializer.
         187  +
    pub fn deserialize_with_response(
         188  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         189  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         190  +
        _status: u16,
         191  +
        _body: &[u8],
         192  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         193  +
        #[allow(unused_variables, unused_mut)]
         194  +
        let mut builder = Self::builder();
         195  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         196  +
            builder._request_id = Some(val.to_string());
         197  +
        }
         198  +
        #[allow(
         199  +
            unused_variables,
         200  +
            unreachable_code,
         201  +
            clippy::single_match,
         202  +
            clippy::match_single_binding,
         203  +
            clippy::diverging_sub_expression
         204  +
        )]
         205  +
        deserializer.read_struct(&CREATEACCESSGRANTSLOCATIONOUTPUT_SCHEMA, &mut |member, deser| {
  149    206   
            match member.member_index() {
  150    207   
                Some(0) => {
  151    208   
                    builder.created_at = Some(deser.read_timestamp(member)?);
  152    209   
                }
  153    210   
                Some(1) => {
  154    211   
                    builder.access_grants_location_id = Some(deser.read_string(member)?);
  155    212   
                }
  156    213   
                Some(2) => {
  157    214   
                    builder.access_grants_location_arn = Some(deser.read_string(member)?);
  158    215   
                }

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/create_access_point.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 `CreateAccessPoint`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CreateAccessPoint;
    6      6   
impl CreateAccessPoint {
    7      7   
    /// Creates a new `CreateAccessPoint`
    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::create_access_point::CreateAccessPointInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::create_access_point::CreateAccessPointOutput::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::create_access_point::CreateAccessPointInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::create_access_point::CreateAccessPointOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::create_access_point::CreateAccessPointError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -118,122 +180,185 @@
  138    142   
                crate::operation::create_access_point::CreateAccessPointError,
  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 CreateAccessPointResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateAccessPointResponseDeserializer {
  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_create_access_point::de_create_access_point_http_error(status, headers, body)
  160    165   
        } else {

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

@@ -89,89 +331,394 @@
  109    109   
    "com.amazonaws.s3control.synthetic",
  110    110   
    "CreateAccessPointInput",
  111    111   
);
  112    112   
static CREATEACCESSPOINTINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.s3control.synthetic#CreateAccessPointInput$AccountId",
  115    115   
        "com.amazonaws.s3control.synthetic",
  116    116   
        "CreateAccessPointInput",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::String,
  119         -
    "account_id",
         119  +
    "AccountId",
  120    120   
    0,
  121    121   
)
  122    122   
.with_host_label()
  123    123   
.with_http_header("x-amz-account-id");
  124    124   
static CREATEACCESSPOINTINPUT_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static(
  126    126   
        "com.amazonaws.s3control.synthetic#CreateAccessPointInput$Name",
  127    127   
        "com.amazonaws.s3control.synthetic",
  128    128   
        "CreateAccessPointInput",
  129    129   
    ),
  130    130   
    ::aws_smithy_schema::ShapeType::String,
  131         -
    "name",
         131  +
    "Name",
  132    132   
    1,
  133    133   
)
  134    134   
.with_http_label();
  135    135   
static CREATEACCESSPOINTINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static(
  137    137   
        "com.amazonaws.s3control.synthetic#CreateAccessPointInput$Bucket",
  138    138   
        "com.amazonaws.s3control.synthetic",
  139    139   
        "CreateAccessPointInput",
  140    140   
    ),
  141    141   
    ::aws_smithy_schema::ShapeType::String,
  142         -
    "bucket",
         142  +
    "Bucket",
  143    143   
    2,
  144    144   
);
  145    145   
static CREATEACCESSPOINTINPUT_MEMBER_VPC_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static(
  147    147   
        "com.amazonaws.s3control.synthetic#CreateAccessPointInput$VpcConfiguration",
  148    148   
        "com.amazonaws.s3control.synthetic",
  149    149   
        "CreateAccessPointInput",
  150    150   
    ),
  151    151   
    ::aws_smithy_schema::ShapeType::Structure,
  152         -
    "vpc_configuration",
         152  +
    "VpcConfiguration",
  153    153   
    3,
  154    154   
);
  155    155   
static CREATEACCESSPOINTINPUT_MEMBER_PUBLIC_ACCESS_BLOCK_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  156    156   
    ::aws_smithy_schema::ShapeId::from_static(
  157    157   
        "com.amazonaws.s3control.synthetic#CreateAccessPointInput$PublicAccessBlockConfiguration",
  158    158   
        "com.amazonaws.s3control.synthetic",
  159    159   
        "CreateAccessPointInput",
  160    160   
    ),
  161    161   
    ::aws_smithy_schema::ShapeType::Structure,
  162         -
    "public_access_block_configuration",
         162  +
    "PublicAccessBlockConfiguration",
  163    163   
    4,
  164    164   
);
  165    165   
static CREATEACCESSPOINTINPUT_MEMBER_BUCKET_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  166    166   
    ::aws_smithy_schema::ShapeId::from_static(
  167    167   
        "com.amazonaws.s3control.synthetic#CreateAccessPointInput$BucketAccountId",
  168    168   
        "com.amazonaws.s3control.synthetic",
  169    169   
        "CreateAccessPointInput",
  170    170   
    ),
  171    171   
    ::aws_smithy_schema::ShapeType::String,
  172         -
    "bucket_account_id",
         172  +
    "BucketAccountId",
  173    173   
    5,
  174    174   
);
  175    175   
static CREATEACCESSPOINTINPUT_MEMBER_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  176    176   
    ::aws_smithy_schema::ShapeId::from_static(
  177    177   
        "com.amazonaws.s3control.synthetic#CreateAccessPointInput$Scope",
  178    178   
        "com.amazonaws.s3control.synthetic",
  179    179   
        "CreateAccessPointInput",
  180    180   
    ),
  181    181   
    ::aws_smithy_schema::ShapeType::Structure,
  182         -
    "scope",
         182  +
    "Scope",
  183    183   
    6,
  184    184   
);
  185    185   
static CREATEACCESSPOINTINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  186    186   
    ::aws_smithy_schema::ShapeId::from_static(
  187    187   
        "com.amazonaws.s3control.synthetic#CreateAccessPointInput$Tags",
  188    188   
        "com.amazonaws.s3control.synthetic",
  189    189   
        "CreateAccessPointInput",
  190    190   
    ),
  191    191   
    ::aws_smithy_schema::ShapeType::List,
  192         -
    "tags",
         192  +
    "Tags",
  193    193   
    7,
  194    194   
);
  195    195   
static CREATEACCESSPOINTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  196    196   
    CREATEACCESSPOINTINPUT_SCHEMA_ID,
  197    197   
    ::aws_smithy_schema::ShapeType::Structure,
  198    198   
    &[
  199    199   
        &CREATEACCESSPOINTINPUT_MEMBER_ACCOUNT_ID,
  200    200   
        &CREATEACCESSPOINTINPUT_MEMBER_NAME,
  201    201   
        &CREATEACCESSPOINTINPUT_MEMBER_BUCKET,
  202    202   
        &CREATEACCESSPOINTINPUT_MEMBER_VPC_CONFIGURATION,
  203    203   
        &CREATEACCESSPOINTINPUT_MEMBER_PUBLIC_ACCESS_BLOCK_CONFIGURATION,
  204    204   
        &CREATEACCESSPOINTINPUT_MEMBER_BUCKET_ACCOUNT_ID,
  205    205   
        &CREATEACCESSPOINTINPUT_MEMBER_SCOPE,
  206    206   
        &CREATEACCESSPOINTINPUT_MEMBER_TAGS,
  207    207   
    ],
  208         -
);
         208  +
)
         209  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/v20180820/accesspoint/{Name}", None));
  209    210   
impl CreateAccessPointInput {
  210    211   
    /// The schema for this shape.
  211    212   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEACCESSPOINTINPUT_SCHEMA;
  212    213   
}
  213    214   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateAccessPointInput {
  214    215   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  215    216   
    fn serialize_members(
  216    217   
        &self,
  217    218   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  218    219   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  219    220   
        if let Some(ref val) = self.account_id {
  220    221   
            ser.write_string(&CREATEACCESSPOINTINPUT_MEMBER_ACCOUNT_ID, val)?;
  221    222   
        }
  222    223   
        if let Some(ref val) = self.name {
  223    224   
            ser.write_string(&CREATEACCESSPOINTINPUT_MEMBER_NAME, val)?;
  224    225   
        }
  225    226   
        if let Some(ref val) = self.bucket {
  226    227   
            ser.write_string(&CREATEACCESSPOINTINPUT_MEMBER_BUCKET, val)?;
  227    228   
        }
  228    229   
        if let Some(ref val) = self.vpc_configuration {
  229    230   
            ser.write_struct(&CREATEACCESSPOINTINPUT_MEMBER_VPC_CONFIGURATION, val)?;
  230    231   
        }
  231    232   
        if let Some(ref val) = self.public_access_block_configuration {
  232    233   
            ser.write_struct(&CREATEACCESSPOINTINPUT_MEMBER_PUBLIC_ACCESS_BLOCK_CONFIGURATION, val)?;
  233    234   
        }
  234    235   
        if let Some(ref val) = self.bucket_account_id {
  235    236   
            ser.write_string(&CREATEACCESSPOINTINPUT_MEMBER_BUCKET_ACCOUNT_ID, val)?;
  236    237   
        }
  237    238   
        if let Some(ref val) = self.scope {
  238    239   
            ser.write_struct(&CREATEACCESSPOINTINPUT_MEMBER_SCOPE, val)?;
  239    240   
        }
  240    241   
        if let Some(ref val) = self.tags {
  241    242   
            ser.write_list(
  242    243   
                &CREATEACCESSPOINTINPUT_MEMBER_TAGS,
  243    244   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  244    245   
                    for item in val {
  245    246   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  246    247   
                    }
  247    248   
                    Ok(())
  248    249   
                },
  249    250   
            )?;
  250    251   
        }
  251    252   
        Ok(())
  252    253   
    }
  253    254   
}
  254    255   
impl CreateAccessPointInput {
  255    256   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  256         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  257         -
        deserializer: &mut D,
         257  +
    pub fn deserialize(
         258  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  258    259   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  259    260   
        #[allow(unused_variables, unused_mut)]
  260    261   
        let mut builder = Self::builder();
  261    262   
        #[allow(
  262    263   
            unused_variables,
  263    264   
            unreachable_code,
  264    265   
            clippy::single_match,
  265    266   
            clippy::match_single_binding,
  266    267   
            clippy::diverging_sub_expression
  267    268   
        )]
  268         -
        deserializer.read_struct(&CREATEACCESSPOINTINPUT_SCHEMA, (), |_, member, deser| {
         269  +
        deserializer.read_struct(&CREATEACCESSPOINTINPUT_SCHEMA, &mut |member, deser| {
  269    270   
            match member.member_index() {
  270    271   
                Some(0) => {
  271    272   
                    builder.account_id = Some(deser.read_string(member)?);
  272    273   
                }
  273    274   
                Some(1) => {
  274    275   
                    builder.name = Some(deser.read_string(member)?);
  275    276   
                }
  276    277   
                Some(2) => {
  277    278   
                    builder.bucket = Some(deser.read_string(member)?);
  278    279   
                }
  279    280   
                Some(3) => {
  280    281   
                    builder.vpc_configuration = Some(crate::types::VpcConfiguration::deserialize(deser)?);
  281    282   
                }
  282    283   
                Some(4) => {
  283    284   
                    builder.public_access_block_configuration = Some(crate::types::PublicAccessBlockConfiguration::deserialize(deser)?);
  284    285   
                }
  285    286   
                Some(5) => {
  286    287   
                    builder.bucket_account_id = Some(deser.read_string(member)?);
  287    288   
                }
  288    289   
                Some(6) => {
  289    290   
                    builder.scope = Some(crate::types::Scope::deserialize(deser)?);
  290    291   
                }
  291    292   
                Some(7) => {
  292    293   
                    builder.tags = Some({
  293         -
                        let container = if let Some(cap) = deser.container_size() {
  294         -
                            Vec::with_capacity(cap)
  295         -
                        } else {
  296         -
                            Vec::new()
  297         -
                        };
  298         -
                        deser.read_list(member, container, |mut list, deser| {
  299         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  300         -
                            Ok(list)
  301         -
                        })?
         294  +
                        let mut container = Vec::new();
         295  +
                        deser.read_list(member, &mut |deser| {
         296  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         297  +
                            Ok(())
         298  +
                        })?;
         299  +
                        container
         300  +
                    });
         301  +
                }
         302  +
                _ => {}
         303  +
            }
         304  +
            Ok(())
         305  +
        })?;
         306  +
        builder.account_id = builder.account_id.or(Some(String::new()));
         307  +
        builder.name = builder.name.or(Some(String::new()));
         308  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         309  +
        builder
         310  +
            .build()
         311  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         312  +
    }
         313  +
}
         314  +
impl CreateAccessPointInput {
         315  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         316  +
    /// Header-bound members are read directly from headers, avoiding runtime
         317  +
    /// member iteration overhead. Body members are read via the deserializer.
         318  +
    pub fn deserialize_with_response(
         319  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         320  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         321  +
        _status: u16,
         322  +
        _body: &[u8],
         323  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         324  +
        #[allow(unused_variables, unused_mut)]
         325  +
        let mut builder = Self::builder();
         326  +
        if let Some(val) = headers.get("x-amz-account-id") {
         327  +
            builder.account_id = Some(val.to_string());
         328  +
        }
         329  +
        #[allow(
         330  +
            unused_variables,
         331  +
            unreachable_code,
         332  +
            clippy::single_match,
         333  +
            clippy::match_single_binding,
         334  +
            clippy::diverging_sub_expression
         335  +
        )]
         336  +
        deserializer.read_struct(&CREATEACCESSPOINTINPUT_SCHEMA, &mut |member, deser| {
         337  +
            match member.member_index() {
         338  +
                Some(0) => { /* read from headers above */ }
         339  +
                Some(1) => {
         340  +
                    builder.name = Some(deser.read_string(member)?);
         341  +
                }
         342  +
                Some(2) => {
         343  +
                    builder.bucket = Some(deser.read_string(member)?);
         344  +
                }
         345  +
                Some(3) => {
         346  +
                    builder.vpc_configuration = Some(crate::types::VpcConfiguration::deserialize(deser)?);
         347  +
                }
         348  +
                Some(4) => {
         349  +
                    builder.public_access_block_configuration = Some(crate::types::PublicAccessBlockConfiguration::deserialize(deser)?);
         350  +
                }
         351  +
                Some(5) => {
         352  +
                    builder.bucket_account_id = Some(deser.read_string(member)?);
         353  +
                }
         354  +
                Some(6) => {
         355  +
                    builder.scope = Some(crate::types::Scope::deserialize(deser)?);
         356  +
                }
         357  +
                Some(7) => {
         358  +
                    builder.tags = Some({
         359  +
                        let mut container = Vec::new();
         360  +
                        deser.read_list(member, &mut |deser| {
         361  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         362  +
                            Ok(())
         363  +
                        })?;
         364  +
                        container
  302    365   
                    });
  303    366   
                }
  304    367   
                _ => {}
  305    368   
            }
  306    369   
            Ok(())
  307    370   
        })?;
  308    371   
        builder
  309    372   
            .build()
  310    373   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  311    374   
    }

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

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

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

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

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

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

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

@@ -5,5 +119,167 @@
   25     25   
    "CreateAccessPointForObjectLambdaOutput",
   26     26   
);
   27     27   
static CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_MEMBER_OBJECT_LAMBDA_ACCESS_POINT_ARN: ::aws_smithy_schema::Schema =
   28     28   
    ::aws_smithy_schema::Schema::new_member(
   29     29   
        ::aws_smithy_schema::ShapeId::from_static(
   30     30   
            "com.amazonaws.s3control.synthetic#CreateAccessPointForObjectLambdaOutput$ObjectLambdaAccessPointArn",
   31     31   
            "com.amazonaws.s3control.synthetic",
   32     32   
            "CreateAccessPointForObjectLambdaOutput",
   33     33   
        ),
   34     34   
        ::aws_smithy_schema::ShapeType::String,
   35         -
        "object_lambda_access_point_arn",
          35  +
        "ObjectLambdaAccessPointArn",
   36     36   
        0,
   37     37   
    );
   38     38   
static CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_MEMBER_ALIAS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.s3control.synthetic#CreateAccessPointForObjectLambdaOutput$Alias",
   41     41   
        "com.amazonaws.s3control.synthetic",
   42     42   
        "CreateAccessPointForObjectLambdaOutput",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::Structure,
   45         -
    "alias",
          45  +
    "Alias",
   46     46   
    1,
   47     47   
);
          48  +
static CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_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 CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     56   
    CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_SCHEMA_ID,
   50     57   
    ::aws_smithy_schema::ShapeType::Structure,
   51     58   
    &[
   52     59   
        &CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_MEMBER_OBJECT_LAMBDA_ACCESS_POINT_ARN,
   53     60   
        &CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_MEMBER_ALIAS,
          61  +
        &CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_MEMBER__REQUEST_ID,
   54     62   
    ],
   55     63   
);
   56     64   
impl CreateAccessPointForObjectLambdaOutput {
   57     65   
    /// The schema for this shape.
   58     66   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_SCHEMA;
   59     67   
}
   60     68   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateAccessPointForObjectLambdaOutput {
   61     69   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   62     70   
    fn serialize_members(
   63     71   
        &self,
   64     72   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   65     73   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   66     74   
        if let Some(ref val) = self.object_lambda_access_point_arn {
   67     75   
            ser.write_string(&CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_MEMBER_OBJECT_LAMBDA_ACCESS_POINT_ARN, val)?;
   68     76   
        }
   69     77   
        if let Some(ref val) = self.alias {
   70     78   
            ser.write_struct(&CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_MEMBER_ALIAS, val)?;
   71     79   
        }
   72     80   
        Ok(())
   73     81   
    }
   74     82   
}
   75     83   
impl CreateAccessPointForObjectLambdaOutput {
   76     84   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   77         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   78         -
        deserializer: &mut D,
          85  +
    pub fn deserialize(
          86  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   79     87   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   80     88   
        #[allow(unused_variables, unused_mut)]
   81     89   
        let mut builder = Self::builder();
   82     90   
        #[allow(
   83     91   
            unused_variables,
   84     92   
            unreachable_code,
   85     93   
            clippy::single_match,
   86     94   
            clippy::match_single_binding,
   87     95   
            clippy::diverging_sub_expression
   88     96   
        )]
   89         -
        deserializer.read_struct(&CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_SCHEMA, (), |_, member, deser| {
          97  +
        deserializer.read_struct(&CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_SCHEMA, &mut |member, deser| {
          98  +
            match member.member_index() {
          99  +
                Some(0) => {
         100  +
                    builder.object_lambda_access_point_arn = Some(deser.read_string(member)?);
         101  +
                }
         102  +
                Some(1) => {
         103  +
                    builder.alias = Some(crate::types::ObjectLambdaAccessPointAlias::deserialize(deser)?);
         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 CreateAccessPointForObjectLambdaOutput {
         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(&CREATEACCESSPOINTFOROBJECTLAMBDAOUTPUT_SCHEMA, &mut |member, deser| {
   90    138   
            match member.member_index() {
   91    139   
                Some(0) => {
   92    140   
                    builder.object_lambda_access_point_arn = Some(deser.read_string(member)?);
   93    141   
                }
   94    142   
                Some(1) => {
   95    143   
                    builder.alias = Some(crate::types::ObjectLambdaAccessPointAlias::deserialize(deser)?);
   96    144   
                }
   97    145   
                _ => {}
   98    146   
            }
   99    147   
            Ok(())