AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c

Files changed:

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/error/_no_such_key.rs

@@ -1,1 +95,106 @@
    6      6   
pub struct NoSuchKey {
    7      7   
    #[allow(missing_docs)] // documentation missing in model
    8      8   
    pub message: ::std::option::Option<::std::string::String>,
    9      9   
    pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,
   10     10   
}
   11     11   
static NOSUCHKEY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   12     12   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#NoSuchKey", "com.amazonaws.s3", "NoSuchKey");
   13     13   
static NOSUCHKEY_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   14     14   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#NoSuchKey$Message", "com.amazonaws.s3", "NoSuchKey"),
   15     15   
    ::aws_smithy_schema::ShapeType::String,
   16         -
    "message",
          16  +
    "Message",
   17     17   
    0,
   18     18   
);
   19     19   
static NOSUCHKEY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   20     20   
    NOSUCHKEY_SCHEMA_ID,
   21     21   
    ::aws_smithy_schema::ShapeType::Structure,
   22     22   
    &[&NOSUCHKEY_MEMBER_MESSAGE],
   23     23   
);
   24     24   
impl NoSuchKey {
   25     25   
    /// The schema for this shape.
   26     26   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NOSUCHKEY_SCHEMA;
   27     27   
}
   28     28   
impl ::aws_smithy_schema::serde::SerializableStruct for NoSuchKey {
   29     29   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   30     30   
    fn serialize_members(
   31     31   
        &self,
   32     32   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   33     33   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   34     34   
        if let Some(ref val) = self.message {
   35     35   
            ser.write_string(&NOSUCHKEY_MEMBER_MESSAGE, val)?;
   36     36   
        }
   37     37   
        Ok(())
   38     38   
    }
   39     39   
}
   40     40   
impl NoSuchKey {
   41     41   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   42         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   43         -
        deserializer: &mut D,
          42  +
    pub fn deserialize(
          43  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   44     44   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   45     45   
        #[allow(unused_variables, unused_mut)]
   46     46   
        let mut builder = Self::builder();
   47     47   
        #[allow(
   48     48   
            unused_variables,
   49     49   
            unreachable_code,
   50     50   
            clippy::single_match,
   51     51   
            clippy::match_single_binding,
   52     52   
            clippy::diverging_sub_expression
   53     53   
        )]
   54         -
        deserializer.read_struct(&NOSUCHKEY_SCHEMA, (), |_, member, deser| {
          54  +
        deserializer.read_struct(&NOSUCHKEY_SCHEMA, &mut |member, deser| {
   55     55   
            match member.member_index() {
   56     56   
                Some(0) => {
   57     57   
                    builder.message = Some(deser.read_string(member)?);
   58     58   
                }
   59     59   
                _ => {}
   60     60   
            }
   61     61   
            Ok(())
   62     62   
        })?;
   63     63   
        Ok(builder.build())
   64     64   
    }
   65     65   
}
          66  +
impl NoSuchKey {
          67  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          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  +
        Self::deserialize(deserializer)
          75  +
    }
          76  +
}
   66     77   
impl NoSuchKey {
   67     78   
    /// Returns the error message.
   68     79   
    pub fn message(&self) -> ::std::option::Option<&str> {
   69     80   
        self.message.as_deref()
   70     81   
    }
   71     82   
}
   72     83   
impl ::std::fmt::Display for NoSuchKey {
   73     84   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   74     85   
        ::std::write!(f, "NoSuchKey")?;
   75     86   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/error/_no_such_upload.rs

@@ -1,1 +95,106 @@
    6      6   
pub struct NoSuchUpload {
    7      7   
    #[allow(missing_docs)] // documentation missing in model
    8      8   
    pub message: ::std::option::Option<::std::string::String>,
    9      9   
    pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,
   10     10   
}
   11     11   
static NOSUCHUPLOAD_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   12     12   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#NoSuchUpload", "com.amazonaws.s3", "NoSuchUpload");
   13     13   
static NOSUCHUPLOAD_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   14     14   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#NoSuchUpload$Message", "com.amazonaws.s3", "NoSuchUpload"),
   15     15   
    ::aws_smithy_schema::ShapeType::String,
   16         -
    "message",
          16  +
    "Message",
   17     17   
    0,
   18     18   
);
   19     19   
static NOSUCHUPLOAD_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   20     20   
    NOSUCHUPLOAD_SCHEMA_ID,
   21     21   
    ::aws_smithy_schema::ShapeType::Structure,
   22     22   
    &[&NOSUCHUPLOAD_MEMBER_MESSAGE],
   23     23   
);
   24     24   
impl NoSuchUpload {
   25     25   
    /// The schema for this shape.
   26     26   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NOSUCHUPLOAD_SCHEMA;
   27     27   
}
   28     28   
impl ::aws_smithy_schema::serde::SerializableStruct for NoSuchUpload {
   29     29   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   30     30   
    fn serialize_members(
   31     31   
        &self,
   32     32   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   33     33   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   34     34   
        if let Some(ref val) = self.message {
   35     35   
            ser.write_string(&NOSUCHUPLOAD_MEMBER_MESSAGE, val)?;
   36     36   
        }
   37     37   
        Ok(())
   38     38   
    }
   39     39   
}
   40     40   
impl NoSuchUpload {
   41     41   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   42         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   43         -
        deserializer: &mut D,
          42  +
    pub fn deserialize(
          43  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   44     44   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   45     45   
        #[allow(unused_variables, unused_mut)]
   46     46   
        let mut builder = Self::builder();
   47     47   
        #[allow(
   48     48   
            unused_variables,
   49     49   
            unreachable_code,
   50     50   
            clippy::single_match,
   51     51   
            clippy::match_single_binding,
   52     52   
            clippy::diverging_sub_expression
   53     53   
        )]
   54         -
        deserializer.read_struct(&NOSUCHUPLOAD_SCHEMA, (), |_, member, deser| {
          54  +
        deserializer.read_struct(&NOSUCHUPLOAD_SCHEMA, &mut |member, deser| {
   55     55   
            match member.member_index() {
   56     56   
                Some(0) => {
   57     57   
                    builder.message = Some(deser.read_string(member)?);
   58     58   
                }
   59     59   
                _ => {}
   60     60   
            }
   61     61   
            Ok(())
   62     62   
        })?;
   63     63   
        Ok(builder.build())
   64     64   
    }
   65     65   
}
          66  +
impl NoSuchUpload {
          67  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          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  +
        Self::deserialize(deserializer)
          75  +
    }
          76  +
}
   66     77   
impl NoSuchUpload {
   67     78   
    /// Returns the error message.
   68     79   
    pub fn message(&self) -> ::std::option::Option<&str> {
   69     80   
        self.message.as_deref()
   70     81   
    }
   71     82   
}
   72     83   
impl ::std::fmt::Display for NoSuchUpload {
   73     84   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   74     85   
        ::std::write!(f, "NoSuchUpload")?;
   75     86   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/error/_not_found.rs

@@ -1,1 +92,103 @@
    6      6   
pub struct NotFound {
    7      7   
    #[allow(missing_docs)] // documentation missing in model
    8      8   
    pub message: ::std::option::Option<::std::string::String>,
    9      9   
    pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,
   10     10   
}
   11     11   
static NOTFOUND_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   12     12   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#NotFound", "com.amazonaws.s3", "NotFound");
   13     13   
static NOTFOUND_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   14     14   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#NotFound$Message", "com.amazonaws.s3", "NotFound"),
   15     15   
    ::aws_smithy_schema::ShapeType::String,
   16         -
    "message",
          16  +
    "Message",
   17     17   
    0,
   18     18   
);
   19     19   
static NOTFOUND_SCHEMA: ::aws_smithy_schema::Schema =
   20     20   
    ::aws_smithy_schema::Schema::new_struct(NOTFOUND_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[&NOTFOUND_MEMBER_MESSAGE]);
   21     21   
impl NotFound {
   22     22   
    /// The schema for this shape.
   23     23   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NOTFOUND_SCHEMA;
   24     24   
}
   25     25   
impl ::aws_smithy_schema::serde::SerializableStruct for NotFound {
   26     26   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   27     27   
    fn serialize_members(
   28     28   
        &self,
   29     29   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   30     30   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   31     31   
        if let Some(ref val) = self.message {
   32     32   
            ser.write_string(&NOTFOUND_MEMBER_MESSAGE, val)?;
   33     33   
        }
   34     34   
        Ok(())
   35     35   
    }
   36     36   
}
   37     37   
impl NotFound {
   38     38   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   39         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   40         -
        deserializer: &mut D,
          39  +
    pub fn deserialize(
          40  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   41     41   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   42     42   
        #[allow(unused_variables, unused_mut)]
   43     43   
        let mut builder = Self::builder();
   44     44   
        #[allow(
   45     45   
            unused_variables,
   46     46   
            unreachable_code,
   47     47   
            clippy::single_match,
   48     48   
            clippy::match_single_binding,
   49     49   
            clippy::diverging_sub_expression
   50     50   
        )]
   51         -
        deserializer.read_struct(&NOTFOUND_SCHEMA, (), |_, member, deser| {
          51  +
        deserializer.read_struct(&NOTFOUND_SCHEMA, &mut |member, deser| {
   52     52   
            match member.member_index() {
   53     53   
                Some(0) => {
   54     54   
                    builder.message = Some(deser.read_string(member)?);
   55     55   
                }
   56     56   
                _ => {}
   57     57   
            }
   58     58   
            Ok(())
   59     59   
        })?;
   60     60   
        Ok(builder.build())
   61     61   
    }
   62     62   
}
          63  +
impl NotFound {
          64  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          65  +
    pub fn deserialize_with_response(
          66  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          67  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          68  +
        _status: u16,
          69  +
        _body: &[u8],
          70  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          71  +
        Self::deserialize(deserializer)
          72  +
    }
          73  +
}
   63     74   
impl NotFound {
   64     75   
    /// Returns the error message.
   65     76   
    pub fn message(&self) -> ::std::option::Option<&str> {
   66     77   
        self.message.as_deref()
   67     78   
    }
   68     79   
}
   69     80   
impl ::std::fmt::Display for NotFound {
   70     81   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   71     82   
        ::std::write!(f, "NotFound")?;
   72     83   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/error/_object_already_in_active_tier_error.rs

@@ -1,1 +102,113 @@
   13     13   
    "com.amazonaws.s3",
   14     14   
    "ObjectAlreadyInActiveTierError",
   15     15   
);
   16     16   
static OBJECTALREADYINACTIVETIERERROR_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.s3#ObjectAlreadyInActiveTierError$Message",
   19     19   
        "com.amazonaws.s3",
   20     20   
        "ObjectAlreadyInActiveTierError",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static OBJECTALREADYINACTIVETIERERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    OBJECTALREADYINACTIVETIERERROR_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&OBJECTALREADYINACTIVETIERERROR_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl ObjectAlreadyInActiveTierError {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OBJECTALREADYINACTIVETIERERROR_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for ObjectAlreadyInActiveTierError {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&OBJECTALREADYINACTIVETIERERROR_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl ObjectAlreadyInActiveTierError {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&OBJECTALREADYINACTIVETIERERROR_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&OBJECTALREADYINACTIVETIERERROR_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl ObjectAlreadyInActiveTierError {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl ObjectAlreadyInActiveTierError {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for ObjectAlreadyInActiveTierError {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "ObjectAlreadyInActiveTierError")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/error/_object_not_in_active_tier_error.rs

@@ -1,1 +102,113 @@
   13     13   
    "com.amazonaws.s3",
   14     14   
    "ObjectNotInActiveTierError",
   15     15   
);
   16     16   
static OBJECTNOTINACTIVETIERERROR_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.s3#ObjectNotInActiveTierError$Message",
   19     19   
        "com.amazonaws.s3",
   20     20   
        "ObjectNotInActiveTierError",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static OBJECTNOTINACTIVETIERERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    OBJECTNOTINACTIVETIERERROR_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&OBJECTNOTINACTIVETIERERROR_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl ObjectNotInActiveTierError {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OBJECTNOTINACTIVETIERERROR_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for ObjectNotInActiveTierError {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&OBJECTNOTINACTIVETIERERROR_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl ObjectNotInActiveTierError {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&OBJECTNOTINACTIVETIERERROR_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&OBJECTNOTINACTIVETIERERROR_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl ObjectNotInActiveTierError {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl ObjectNotInActiveTierError {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for ObjectNotInActiveTierError {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "ObjectNotInActiveTierError")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/error/_too_many_parts.rs

@@ -1,1 +95,106 @@
    6      6   
pub struct TooManyParts {
    7      7   
    #[allow(missing_docs)] // documentation missing in model
    8      8   
    pub message: ::std::option::Option<::std::string::String>,
    9      9   
    pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,
   10     10   
}
   11     11   
static TOOMANYPARTS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   12     12   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#TooManyParts", "com.amazonaws.s3", "TooManyParts");
   13     13   
static TOOMANYPARTS_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   14     14   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#TooManyParts$Message", "com.amazonaws.s3", "TooManyParts"),
   15     15   
    ::aws_smithy_schema::ShapeType::String,
   16         -
    "message",
          16  +
    "Message",
   17     17   
    0,
   18     18   
);
   19     19   
static TOOMANYPARTS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   20     20   
    TOOMANYPARTS_SCHEMA_ID,
   21     21   
    ::aws_smithy_schema::ShapeType::Structure,
   22     22   
    &[&TOOMANYPARTS_MEMBER_MESSAGE],
   23     23   
);
   24     24   
impl TooManyParts {
   25     25   
    /// The schema for this shape.
   26     26   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TOOMANYPARTS_SCHEMA;
   27     27   
}
   28     28   
impl ::aws_smithy_schema::serde::SerializableStruct for TooManyParts {
   29     29   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   30     30   
    fn serialize_members(
   31     31   
        &self,
   32     32   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   33     33   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   34     34   
        if let Some(ref val) = self.message {
   35     35   
            ser.write_string(&TOOMANYPARTS_MEMBER_MESSAGE, val)?;
   36     36   
        }
   37     37   
        Ok(())
   38     38   
    }
   39     39   
}
   40     40   
impl TooManyParts {
   41     41   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   42         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   43         -
        deserializer: &mut D,
          42  +
    pub fn deserialize(
          43  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   44     44   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   45     45   
        #[allow(unused_variables, unused_mut)]
   46     46   
        let mut builder = Self::builder();
   47     47   
        #[allow(
   48     48   
            unused_variables,
   49     49   
            unreachable_code,
   50     50   
            clippy::single_match,
   51     51   
            clippy::match_single_binding,
   52     52   
            clippy::diverging_sub_expression
   53     53   
        )]
   54         -
        deserializer.read_struct(&TOOMANYPARTS_SCHEMA, (), |_, member, deser| {
          54  +
        deserializer.read_struct(&TOOMANYPARTS_SCHEMA, &mut |member, deser| {
   55     55   
            match member.member_index() {
   56     56   
                Some(0) => {
   57     57   
                    builder.message = Some(deser.read_string(member)?);
   58     58   
                }
   59     59   
                _ => {}
   60     60   
            }
   61     61   
            Ok(())
   62     62   
        })?;
   63     63   
        Ok(builder.build())
   64     64   
    }
   65     65   
}
          66  +
impl TooManyParts {
          67  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          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  +
        Self::deserialize(deserializer)
          75  +
    }
          76  +
}
   66     77   
impl TooManyParts {
   67     78   
    /// Returns the error message.
   68     79   
    pub fn message(&self) -> ::std::option::Option<&str> {
   69     80   
        self.message.as_deref()
   70     81   
    }
   71     82   
}
   72     83   
impl ::std::fmt::Display for TooManyParts {
   73     84   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   74     85   
        ::std::write!(f, "TooManyParts")?;
   75     86   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/s3control/Cargo.toml

@@ -1,1 +156,156 @@
   14     14   
protocol = "aws.protocols#restXml"
   15     15   
[package.metadata.docs.rs]
   16     16   
all-features = true
   17     17   
targets = ["x86_64-unknown-linux-gnu"]
   18     18   
[dependencies.aws-credential-types]
   19     19   
path = "../aws-credential-types"
   20     20   
version = "1.2.14"
   21     21   
   22     22   
[dependencies.aws-runtime]
   23     23   
path = "../aws-runtime"
   24         -
version = "1.7.3"
          24  +
version = "1.7.4"
   25     25   
   26     26   
[dependencies.aws-smithy-async]
   27     27   
path = "../aws-smithy-async"
   28     28   
version = "1.2.14"
   29     29   
   30     30   
[dependencies.aws-smithy-http]
   31     31   
path = "../aws-smithy-http"
   32     32   
version = "0.63.6"
   33     33   
   34     34   
[dependencies.aws-smithy-json]
   35     35   
path = "../aws-smithy-json"
   36     36   
version = "0.62.6"
   37     37   
   38     38   
[dependencies.aws-smithy-observability]
   39     39   
path = "../aws-smithy-observability"
   40     40   
version = "0.2.6"
   41     41   
   42     42   
[dependencies.aws-smithy-runtime]
   43     43   
path = "../aws-smithy-runtime"
   44     44   
features = ["client"]
   45         -
version = "1.10.3"
          45  +
version = "1.10.4"
   46     46   
   47     47   
[dependencies.aws-smithy-runtime-api]
   48     48   
path = "../aws-smithy-runtime-api"
   49     49   
features = ["client", "http-1x"]
   50         -
version = "1.11.6"
          50  +
version = "1.11.7"
   51     51   
   52     52   
[dependencies.aws-smithy-schema]
   53     53   
path = "../aws-smithy-schema"
   54     54   
version = "1.0.0"
   55     55   
   56     56   
[dependencies.aws-smithy-types]
   57     57   
path = "../aws-smithy-types"
   58     58   
features = ["http-body-1-x"]
   59     59   
version = "1.4.7"
   60     60   
   61     61   
[dependencies.aws-smithy-xml]
   62     62   
path = "../aws-smithy-xml"
   63     63   
version = "0.60.15"
   64     64   
   65     65   
[dependencies.aws-types]
   66     66   
path = "../aws-types"
   67     67   
version = "1.4.0"
   68     68   
   69     69   
[dependencies.fastrand]
   70     70   
version = "2.0.0"
   71     71   
   72     72   
[dependencies.http]
   73     73   
version = "0.2.9"
   74     74   
   75     75   
[dependencies.http-1x]
   76     76   
version = "1"
   77     77   
package = "http"
   78     78   
   79     79   
[dependencies.md-5]
   80     80   
version = "0.10.0"
   81     81   
   82     82   
[dependencies.regex-lite]
   83     83   
version = "0.1.5"
   84     84   
   85     85   
[dependencies.tracing]
   86     86   
version = "0.1"
   87     87   
   88     88   
[dependencies.url]
   89     89   
version = "2.3.1"
   90     90   
[dev-dependencies.aws-config]
   91     91   
path = "../aws-config"
   92     92   
version = "1.9.0"
   93     93   
   94     94   
[dev-dependencies.aws-credential-types]
   95     95   
path = "../aws-credential-types"
   96     96   
features = ["test-util"]
   97     97   
version = "1.2.14"
   98     98   
   99     99   
[dev-dependencies.aws-runtime]
  100    100   
path = "../aws-runtime"
  101    101   
features = ["test-util"]
  102         -
version = "1.7.3"
         102  +
version = "1.7.4"
  103    103   
  104    104   
[dev-dependencies.aws-smithy-async]
  105    105   
path = "../aws-smithy-async"
  106    106   
features = ["test-util"]
  107    107   
version = "1.2.14"
  108    108   
  109    109   
[dev-dependencies.aws-smithy-http-client]
  110    110   
path = "../aws-smithy-http-client"
  111    111   
features = ["test-util", "wire-mock"]
  112    112   
version = "1.1.12"
  113    113   
  114    114   
[dev-dependencies.aws-smithy-protocol-test]
  115    115   
path = "../aws-smithy-protocol-test"
  116    116   
version = "0.63.14"
  117    117   
  118    118   
[dev-dependencies.aws-smithy-runtime]
  119    119   
path = "../aws-smithy-runtime"
  120    120   
features = ["test-util"]
  121         -
version = "1.10.3"
         121  +
version = "1.10.4"
  122    122   
  123    123   
[dev-dependencies.aws-smithy-runtime-api]
  124    124   
path = "../aws-smithy-runtime-api"
  125    125   
features = ["test-util"]
  126         -
version = "1.11.6"
         126  +
version = "1.11.7"
  127    127   
  128    128   
[dev-dependencies.aws-smithy-types]
  129    129   
path = "../aws-smithy-types"
  130    130   
features = ["http-body-1-x", "test-util"]
  131    131   
version = "1.4.7"
  132    132   
  133    133   
[dev-dependencies.futures-util]
  134    134   
version = "0.3.25"
  135    135   
features = ["alloc"]
  136    136   
default-features = false

tmp-codegen-diff/aws-sdk/sdk/s3control/src/operation/associate_access_grants_identity_center.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 `AssociateAccessGrantsIdentityCenter`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct AssociateAccessGrantsIdentityCenter;
    6      6   
impl AssociateAccessGrantsIdentityCenter {
    7      7   
    /// Creates a new `AssociateAccessGrantsIdentityCenter`
    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::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterOutput::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::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +186,193 @@
  144    150   
                crate::operation::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterError,
  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 AssociateAccessGrantsIdentityCenterResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for AssociateAccessGrantsIdentityCenterResponseDeserializer {
  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_associate_access_grants_identity_center::de_associate_access_grants_identity_center_http_error(
  166    173   
                status, headers, body,

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

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

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   
                }