AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36 (ignoring whitespace)

Files changed:

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

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

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

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

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

@@ -5,5 +142,153 @@
   25     25   
}
   26     26   
static INVALIDOBJECTSTATE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InvalidObjectState", "com.amazonaws.s3", "InvalidObjectState");
   28     28   
static INVALIDOBJECTSTATE_MEMBER_STORAGE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   29     29   
    ::aws_smithy_schema::ShapeId::from_static(
   30     30   
        "com.amazonaws.s3#InvalidObjectState$StorageClass",
   31     31   
        "com.amazonaws.s3",
   32     32   
        "InvalidObjectState",
   33     33   
    ),
   34     34   
    ::aws_smithy_schema::ShapeType::String,
   35         -
    "storage_class",
          35  +
    "StorageClass",
   36     36   
    0,
   37     37   
);
   38     38   
static INVALIDOBJECTSTATE_MEMBER_ACCESS_TIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InvalidObjectState$AccessTier", "com.amazonaws.s3", "InvalidObjectState"),
   40     40   
    ::aws_smithy_schema::ShapeType::String,
   41         -
    "access_tier",
          41  +
    "AccessTier",
   42     42   
    1,
   43     43   
);
   44     44   
static INVALIDOBJECTSTATE_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InvalidObjectState$Message", "com.amazonaws.s3", "InvalidObjectState"),
   46     46   
    ::aws_smithy_schema::ShapeType::String,
   47         -
    "message",
          47  +
    "Message",
   48     48   
    2,
   49     49   
);
   50     50   
static INVALIDOBJECTSTATE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   51     51   
    INVALIDOBJECTSTATE_SCHEMA_ID,
   52     52   
    ::aws_smithy_schema::ShapeType::Structure,
   53     53   
    &[
   54     54   
        &INVALIDOBJECTSTATE_MEMBER_STORAGE_CLASS,
   55     55   
        &INVALIDOBJECTSTATE_MEMBER_ACCESS_TIER,
   56     56   
        &INVALIDOBJECTSTATE_MEMBER_MESSAGE,
   57     57   
    ],
   58     58   
);
   59     59   
impl InvalidObjectState {
   60     60   
    /// The schema for this shape.
   61     61   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVALIDOBJECTSTATE_SCHEMA;
   62     62   
}
   63     63   
impl ::aws_smithy_schema::serde::SerializableStruct for InvalidObjectState {
   64     64   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   65     65   
    fn serialize_members(
   66     66   
        &self,
   67     67   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   68     68   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   69     69   
        if let Some(ref val) = self.storage_class {
   70     70   
            ser.write_string(&INVALIDOBJECTSTATE_MEMBER_STORAGE_CLASS, val.as_str())?;
   71     71   
        }
   72     72   
        if let Some(ref val) = self.access_tier {
   73     73   
            ser.write_string(&INVALIDOBJECTSTATE_MEMBER_ACCESS_TIER, val.as_str())?;
   74     74   
        }
   75     75   
        if let Some(ref val) = self.message {
   76     76   
            ser.write_string(&INVALIDOBJECTSTATE_MEMBER_MESSAGE, val)?;
   77     77   
        }
   78     78   
        Ok(())
   79     79   
    }
   80     80   
}
   81     81   
impl InvalidObjectState {
   82     82   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   83         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   84         -
        deserializer: &mut D,
          83  +
    pub fn deserialize(
          84  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   85     85   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   86     86   
        #[allow(unused_variables, unused_mut)]
   87     87   
        let mut builder = Self::builder();
   88     88   
        #[allow(
   89     89   
            unused_variables,
   90     90   
            unreachable_code,
   91     91   
            clippy::single_match,
   92     92   
            clippy::match_single_binding,
   93     93   
            clippy::diverging_sub_expression
   94     94   
        )]
   95         -
        deserializer.read_struct(&INVALIDOBJECTSTATE_SCHEMA, (), |_, member, deser| {
          95  +
        deserializer.read_struct(&INVALIDOBJECTSTATE_SCHEMA, &mut |member, deser| {
   96     96   
            match member.member_index() {
   97     97   
                Some(0) => {
   98     98   
                    builder.storage_class = Some(crate::types::StorageClass::from(deser.read_string(member)?.as_str()));
   99     99   
                }
  100    100   
                Some(1) => {
  101    101   
                    builder.access_tier = Some(crate::types::IntelligentTieringAccessTier::from(deser.read_string(member)?.as_str()));
  102    102   
                }
  103    103   
                Some(2) => {
  104    104   
                    builder.message = Some(deser.read_string(member)?);
  105    105   
                }
  106    106   
                _ => {}
  107    107   
            }
  108    108   
            Ok(())
  109    109   
        })?;
  110    110   
        Ok(builder.build())
  111    111   
    }
  112    112   
}
         113  +
impl InvalidObjectState {
         114  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         115  +
    pub fn deserialize_with_response(
         116  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         117  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         118  +
        _status: u16,
         119  +
        _body: &[u8],
         120  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         121  +
        Self::deserialize(deserializer)
         122  +
    }
         123  +
}
  113    124   
impl InvalidObjectState {
  114    125   
    /// Returns the error message.
  115    126   
    pub fn message(&self) -> ::std::option::Option<&str> {
  116    127   
        self.message.as_deref()
  117    128   
    }
  118    129   
}
  119    130   
impl ::std::fmt::Display for InvalidObjectState {
  120    131   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  121    132   
        ::std::write!(f, "InvalidObjectState")?;
  122    133   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

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

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

@@ -1,1 +95,106 @@
    6      6   
pub struct InvalidWriteOffset {
    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 INVALIDWRITEOFFSET_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   12     12   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InvalidWriteOffset", "com.amazonaws.s3", "InvalidWriteOffset");
   13     13   
static INVALIDWRITEOFFSET_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   14     14   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InvalidWriteOffset$Message", "com.amazonaws.s3", "InvalidWriteOffset"),
   15     15   
    ::aws_smithy_schema::ShapeType::String,
   16         -
    "message",
          16  +
    "Message",
   17     17   
    0,
   18     18   
);
   19     19   
static INVALIDWRITEOFFSET_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   20     20   
    INVALIDWRITEOFFSET_SCHEMA_ID,
   21     21   
    ::aws_smithy_schema::ShapeType::Structure,
   22     22   
    &[&INVALIDWRITEOFFSET_MEMBER_MESSAGE],
   23     23   
);
   24     24   
impl InvalidWriteOffset {
   25     25   
    /// The schema for this shape.
   26     26   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVALIDWRITEOFFSET_SCHEMA;
   27     27   
}
   28     28   
impl ::aws_smithy_schema::serde::SerializableStruct for InvalidWriteOffset {
   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(&INVALIDWRITEOFFSET_MEMBER_MESSAGE, val)?;
   36     36   
        }
   37     37   
        Ok(())
   38     38   
    }
   39     39   
}
   40     40   
impl InvalidWriteOffset {
   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(&INVALIDWRITEOFFSET_SCHEMA, (), |_, member, deser| {
          54  +
        deserializer.read_struct(&INVALIDWRITEOFFSET_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 InvalidWriteOffset {
          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 InvalidWriteOffset {
   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 InvalidWriteOffset {
   73     84   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   74     85   
        ::std::write!(f, "InvalidWriteOffset")?;
   75     86   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -1,1 +95,106 @@
    6      6   
pub struct NoSuchBucket {
    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 NOSUCHBUCKET_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   12     12   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#NoSuchBucket", "com.amazonaws.s3", "NoSuchBucket");
   13     13   
static NOSUCHBUCKET_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   14     14   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#NoSuchBucket$Message", "com.amazonaws.s3", "NoSuchBucket"),
   15     15   
    ::aws_smithy_schema::ShapeType::String,
   16         -
    "message",
          16  +
    "Message",
   17     17   
    0,
   18     18   
);
   19     19   
static NOSUCHBUCKET_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   20     20   
    NOSUCHBUCKET_SCHEMA_ID,
   21     21   
    ::aws_smithy_schema::ShapeType::Structure,
   22     22   
    &[&NOSUCHBUCKET_MEMBER_MESSAGE],
   23     23   
);
   24     24   
impl NoSuchBucket {
   25     25   
    /// The schema for this shape.
   26     26   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NOSUCHBUCKET_SCHEMA;
   27     27   
}
   28     28   
impl ::aws_smithy_schema::serde::SerializableStruct for NoSuchBucket {
   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(&NOSUCHBUCKET_MEMBER_MESSAGE, val)?;
   36     36   
        }
   37     37   
        Ok(())
   38     38   
    }
   39     39   
}
   40     40   
impl NoSuchBucket {
   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(&NOSUCHBUCKET_SCHEMA, (), |_, member, deser| {
          54  +
        deserializer.read_struct(&NOSUCHBUCKET_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 NoSuchBucket {
          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 NoSuchBucket {
   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 NoSuchBucket {
   73     84   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   74     85   
        ::std::write!(f, "NoSuchBucket")?;
   75     86   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -15,15 +80,80 @@
   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
@@ -91,91 +156,156 @@
  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   
    > {
@@ -127,133 +186,193 @@
  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    160   
    fn deserialize_nonstreaming(
  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   
    }