AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36 (ignoring whitespace)

Files changed:

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

@@ -1,1 +119,130 @@
   17     17   
    /// <p>Specifies the permission given to the grantee.</p>
   18     18   
    pub fn permission(&self) -> ::std::option::Option<&crate::types::Permission> {
   19     19   
        self.permission.as_ref()
   20     20   
    }
   21     21   
}
   22     22   
static GRANT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grant", "com.amazonaws.s3", "Grant");
   24     24   
static GRANT_MEMBER_GRANTEE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grant$Grantee", "com.amazonaws.s3", "Grant"),
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27         -
    "grantee",
          27  +
    "Grantee",
   28     28   
    0,
   29     29   
)
   30     30   
.with_xml_namespace();
   31     31   
static GRANT_MEMBER_PERMISSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grant$Permission", "com.amazonaws.s3", "Grant"),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "permission",
          34  +
    "Permission",
   35     35   
    1,
   36     36   
);
   37     37   
static GRANT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   38     38   
    GRANT_SCHEMA_ID,
   39     39   
    ::aws_smithy_schema::ShapeType::Structure,
   40     40   
    &[&GRANT_MEMBER_GRANTEE, &GRANT_MEMBER_PERMISSION],
   41     41   
);
   42     42   
impl Grant {
   43     43   
    /// The schema for this shape.
   44     44   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GRANT_SCHEMA;
   45     45   
}
   46     46   
impl ::aws_smithy_schema::serde::SerializableStruct for Grant {
   47     47   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   48     48   
    fn serialize_members(
   49     49   
        &self,
   50     50   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   51     51   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        if let Some(ref val) = self.grantee {
   53     53   
            ser.write_struct(&GRANT_MEMBER_GRANTEE, val)?;
   54     54   
        }
   55     55   
        if let Some(ref val) = self.permission {
   56     56   
            ser.write_string(&GRANT_MEMBER_PERMISSION, val.as_str())?;
   57     57   
        }
   58     58   
        Ok(())
   59     59   
    }
   60     60   
}
   61     61   
impl Grant {
   62     62   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   63         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   64         -
        deserializer: &mut D,
          63  +
    pub fn deserialize(
          64  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   65     65   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   66     66   
        #[allow(unused_variables, unused_mut)]
   67     67   
        let mut builder = Self::builder();
   68     68   
        #[allow(
   69     69   
            unused_variables,
   70     70   
            unreachable_code,
   71     71   
            clippy::single_match,
   72     72   
            clippy::match_single_binding,
   73     73   
            clippy::diverging_sub_expression
   74     74   
        )]
   75         -
        deserializer.read_struct(&GRANT_SCHEMA, (), |_, member, deser| {
          75  +
        deserializer.read_struct(&GRANT_SCHEMA, &mut |member, deser| {
   76     76   
            match member.member_index() {
   77     77   
                Some(0) => {
   78     78   
                    builder.grantee = Some(crate::types::Grantee::deserialize(deser)?);
   79     79   
                }
   80     80   
                Some(1) => {
   81     81   
                    builder.permission = Some(crate::types::Permission::from(deser.read_string(member)?.as_str()));
   82     82   
                }
   83     83   
                _ => {}
   84     84   
            }
   85     85   
            Ok(())
   86     86   
        })?;
   87     87   
        Ok(builder.build())
   88     88   
    }
   89     89   
}
          90  +
impl Grant {
          91  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          92  +
    pub fn deserialize_with_response(
          93  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          94  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          95  +
        _status: u16,
          96  +
        _body: &[u8],
          97  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          98  +
        Self::deserialize(deserializer)
          99  +
    }
         100  +
}
   90    101   
impl Grant {
   91    102   
    /// Creates a new builder-style object to manufacture [`Grant`](crate::types::Grant).
   92    103   
    pub fn builder() -> crate::types::builders::GrantBuilder {
   93    104   
        crate::types::builders::GrantBuilder::default()
   94    105   
    }
   95    106   
}
   96    107   
   97    108   
/// A builder for [`Grant`](crate::types::Grant).
   98    109   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   99    110   
#[non_exhaustive]

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

@@ -15,15 +183,194 @@
   35     35   
    /// <p>Type of grantee</p>
   36     36   
    pub fn r#type(&self) -> &crate::types::Type {
   37     37   
        &self.r#type
   38     38   
    }
   39     39   
}
   40     40   
static GRANTEE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   41     41   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grantee", "com.amazonaws.s3", "Grantee");
   42     42   
static GRANTEE_MEMBER_DISPLAY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grantee$DisplayName", "com.amazonaws.s3", "Grantee"),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45         -
    "display_name",
          45  +
    "DisplayName",
   46     46   
    0,
   47     47   
);
   48     48   
static GRANTEE_MEMBER_EMAIL_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grantee$EmailAddress", "com.amazonaws.s3", "Grantee"),
   50     50   
    ::aws_smithy_schema::ShapeType::String,
   51         -
    "email_address",
          51  +
    "EmailAddress",
   52     52   
    1,
   53     53   
);
   54     54   
static GRANTEE_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grantee$ID", "com.amazonaws.s3", "Grantee"),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "id",
          57  +
    "ID",
   58     58   
    2,
   59     59   
);
   60     60   
static GRANTEE_MEMBER_URI: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grantee$URI", "com.amazonaws.s3", "Grantee"),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "uri",
          63  +
    "URI",
   64     64   
    3,
   65     65   
);
   66     66   
static GRANTEE_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Grantee$Type", "com.amazonaws.s3", "Grantee"),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "r##type",
          69  +
    "Type",
   70     70   
    4,
   71     71   
)
   72     72   
.with_xml_name("xsi:type")
   73     73   
.with_xml_attribute();
   74     74   
static GRANTEE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   75     75   
    GRANTEE_SCHEMA_ID,
   76     76   
    ::aws_smithy_schema::ShapeType::Structure,
   77     77   
    &[
   78     78   
        &GRANTEE_MEMBER_DISPLAY_NAME,
   79     79   
        &GRANTEE_MEMBER_EMAIL_ADDRESS,
   80     80   
        &GRANTEE_MEMBER_ID,
   81     81   
        &GRANTEE_MEMBER_URI,
   82     82   
        &GRANTEE_MEMBER_TYPE,
   83     83   
    ],
   84     84   
);
   85     85   
impl Grantee {
   86     86   
    /// The schema for this shape.
   87     87   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GRANTEE_SCHEMA;
   88     88   
}
   89     89   
impl ::aws_smithy_schema::serde::SerializableStruct for Grantee {
   90     90   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   91     91   
    fn serialize_members(
   92     92   
        &self,
   93     93   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   94     94   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   95     95   
        if let Some(ref val) = self.display_name {
   96     96   
            ser.write_string(&GRANTEE_MEMBER_DISPLAY_NAME, val)?;
   97     97   
        }
   98     98   
        if let Some(ref val) = self.email_address {
   99     99   
            ser.write_string(&GRANTEE_MEMBER_EMAIL_ADDRESS, val)?;
  100    100   
        }
  101    101   
        if let Some(ref val) = self.id {
  102    102   
            ser.write_string(&GRANTEE_MEMBER_ID, val)?;
  103    103   
        }
  104    104   
        if let Some(ref val) = self.uri {
  105    105   
            ser.write_string(&GRANTEE_MEMBER_URI, val)?;
  106    106   
        }
  107    107   
        {
  108    108   
            let val = &self.r#type;
  109    109   
            ser.write_string(&GRANTEE_MEMBER_TYPE, val.as_str())?;
  110    110   
        }
  111    111   
        Ok(())
  112    112   
    }
  113    113   
}
  114    114   
impl Grantee {
  115    115   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  116         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  117         -
        deserializer: &mut D,
         116  +
    pub fn deserialize(
         117  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  118    118   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  119    119   
        #[allow(unused_variables, unused_mut)]
  120    120   
        let mut builder = Self::builder();
  121    121   
        #[allow(
  122    122   
            unused_variables,
  123    123   
            unreachable_code,
  124    124   
            clippy::single_match,
  125    125   
            clippy::match_single_binding,
  126    126   
            clippy::diverging_sub_expression
  127    127   
        )]
  128         -
        deserializer.read_struct(&GRANTEE_SCHEMA, (), |_, member, deser| {
         128  +
        deserializer.read_struct(&GRANTEE_SCHEMA, &mut |member, deser| {
  129    129   
            match member.member_index() {
  130    130   
                Some(0) => {
  131    131   
                    builder.display_name = Some(deser.read_string(member)?);
  132    132   
                }
  133    133   
                Some(1) => {
  134    134   
                    builder.email_address = Some(deser.read_string(member)?);
  135    135   
                }
  136    136   
                Some(2) => {
  137    137   
                    builder.id = Some(deser.read_string(member)?);
  138    138   
                }
  139    139   
                Some(3) => {
  140    140   
                    builder.uri = Some(deser.read_string(member)?);
  141    141   
                }
  142    142   
                Some(4) => {
  143    143   
                    builder.r#type = Some(crate::types::Type::from(deser.read_string(member)?.as_str()));
  144    144   
                }
  145    145   
                _ => {}
  146    146   
            }
  147    147   
            Ok(())
  148    148   
        })?;
  149    149   
        builder
  150    150   
            .build()
  151    151   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  152    152   
    }
  153    153   
}
         154  +
impl Grantee {
         155  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         156  +
    pub fn deserialize_with_response(
         157  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         158  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         159  +
        _status: u16,
         160  +
        _body: &[u8],
         161  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         162  +
        Self::deserialize(deserializer)
         163  +
    }
         164  +
}
  154    165   
impl Grantee {
  155    166   
    /// Creates a new builder-style object to manufacture [`Grantee`](crate::types::Grantee).
  156    167   
    pub fn builder() -> crate::types::builders::GranteeBuilder {
  157    168   
        crate::types::builders::GranteeBuilder::default()
  158    169   
    }
  159    170   
}
  160    171   
  161    172   
/// A builder for [`Grantee`](crate::types::Grantee).
  162    173   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  163    174   
#[non_exhaustive]

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

@@ -1,1 +108,120 @@
   16     16   
    pub fn suffix(&self) -> &str {
   17     17   
        use std::ops::Deref;
   18     18   
        self.suffix.deref()
   19     19   
    }
   20     20   
}
   21     21   
static INDEXDOCUMENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   22     22   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#IndexDocument", "com.amazonaws.s3", "IndexDocument");
   23     23   
static INDEXDOCUMENT_MEMBER_SUFFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   24     24   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#IndexDocument$Suffix", "com.amazonaws.s3", "IndexDocument"),
   25     25   
    ::aws_smithy_schema::ShapeType::String,
   26         -
    "suffix",
          26  +
    "Suffix",
   27     27   
    0,
   28     28   
);
   29     29   
static INDEXDOCUMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   30     30   
    INDEXDOCUMENT_SCHEMA_ID,
   31     31   
    ::aws_smithy_schema::ShapeType::Structure,
   32     32   
    &[&INDEXDOCUMENT_MEMBER_SUFFIX],
   33     33   
);
   34     34   
impl IndexDocument {
   35     35   
    /// The schema for this shape.
   36     36   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INDEXDOCUMENT_SCHEMA;
   37     37   
}
   38     38   
impl ::aws_smithy_schema::serde::SerializableStruct for IndexDocument {
   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   
        {
   45     45   
            let val = &self.suffix;
   46     46   
            ser.write_string(&INDEXDOCUMENT_MEMBER_SUFFIX, val)?;
   47     47   
        }
   48     48   
        Ok(())
   49     49   
    }
   50     50   
}
   51     51   
impl IndexDocument {
   52     52   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   53         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   54         -
        deserializer: &mut D,
          53  +
    pub fn deserialize(
          54  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   55     55   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   56     56   
        #[allow(unused_variables, unused_mut)]
   57     57   
        let mut builder = Self::builder();
   58     58   
        #[allow(
   59     59   
            unused_variables,
   60     60   
            unreachable_code,
   61     61   
            clippy::single_match,
   62     62   
            clippy::match_single_binding,
   63     63   
            clippy::diverging_sub_expression
   64     64   
        )]
   65         -
        deserializer.read_struct(&INDEXDOCUMENT_SCHEMA, (), |_, member, deser| {
          65  +
        deserializer.read_struct(&INDEXDOCUMENT_SCHEMA, &mut |member, deser| {
   66     66   
            match member.member_index() {
   67     67   
                Some(0) => {
   68     68   
                    builder.suffix = Some(deser.read_string(member)?);
   69     69   
                }
   70     70   
                _ => {}
   71     71   
            }
   72     72   
            Ok(())
   73     73   
        })?;
          74  +
        builder.suffix = builder.suffix.or(Some(String::new()));
   74     75   
        builder
   75     76   
            .build()
   76     77   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   77     78   
    }
   78     79   
}
          80  +
impl IndexDocument {
          81  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          82  +
    pub fn deserialize_with_response(
          83  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          84  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          85  +
        _status: u16,
          86  +
        _body: &[u8],
          87  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          88  +
        Self::deserialize(deserializer)
          89  +
    }
          90  +
}
   79     91   
impl IndexDocument {
   80     92   
    /// Creates a new builder-style object to manufacture [`IndexDocument`](crate::types::IndexDocument).
   81     93   
    pub fn builder() -> crate::types::builders::IndexDocumentBuilder {
   82     94   
        crate::types::builders::IndexDocumentBuilder::default()
   83     95   
    }
   84     96   
}
   85     97   
   86     98   
/// A builder for [`IndexDocument`](crate::types::IndexDocument).
   87     99   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88    100   
#[non_exhaustive]

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

@@ -5,5 +126,137 @@
   25     25   
    /// </note>
   26     26   
    pub fn display_name(&self) -> ::std::option::Option<&str> {
   27     27   
        self.display_name.as_deref()
   28     28   
    }
   29     29   
}
   30     30   
static INITIATOR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Initiator", "com.amazonaws.s3", "Initiator");
   32     32   
static INITIATOR_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Initiator$ID", "com.amazonaws.s3", "Initiator"),
   34     34   
    ::aws_smithy_schema::ShapeType::String,
   35         -
    "id",
          35  +
    "ID",
   36     36   
    0,
   37     37   
);
   38     38   
static INITIATOR_MEMBER_DISPLAY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Initiator$DisplayName", "com.amazonaws.s3", "Initiator"),
   40     40   
    ::aws_smithy_schema::ShapeType::String,
   41         -
    "display_name",
          41  +
    "DisplayName",
   42     42   
    1,
   43     43   
);
   44     44   
static INITIATOR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   45     45   
    INITIATOR_SCHEMA_ID,
   46     46   
    ::aws_smithy_schema::ShapeType::Structure,
   47     47   
    &[&INITIATOR_MEMBER_ID, &INITIATOR_MEMBER_DISPLAY_NAME],
   48     48   
);
   49     49   
impl Initiator {
   50     50   
    /// The schema for this shape.
   51     51   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INITIATOR_SCHEMA;
   52     52   
}
   53     53   
impl ::aws_smithy_schema::serde::SerializableStruct for Initiator {
   54     54   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   55     55   
    fn serialize_members(
   56     56   
        &self,
   57     57   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   58     58   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   59     59   
        if let Some(ref val) = self.id {
   60     60   
            ser.write_string(&INITIATOR_MEMBER_ID, val)?;
   61     61   
        }
   62     62   
        if let Some(ref val) = self.display_name {
   63     63   
            ser.write_string(&INITIATOR_MEMBER_DISPLAY_NAME, val)?;
   64     64   
        }
   65     65   
        Ok(())
   66     66   
    }
   67     67   
}
   68     68   
impl Initiator {
   69     69   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   70         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   71         -
        deserializer: &mut D,
          70  +
    pub fn deserialize(
          71  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   72     72   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   73     73   
        #[allow(unused_variables, unused_mut)]
   74     74   
        let mut builder = Self::builder();
   75     75   
        #[allow(
   76     76   
            unused_variables,
   77     77   
            unreachable_code,
   78     78   
            clippy::single_match,
   79     79   
            clippy::match_single_binding,
   80     80   
            clippy::diverging_sub_expression
   81     81   
        )]
   82         -
        deserializer.read_struct(&INITIATOR_SCHEMA, (), |_, member, deser| {
          82  +
        deserializer.read_struct(&INITIATOR_SCHEMA, &mut |member, deser| {
   83     83   
            match member.member_index() {
   84     84   
                Some(0) => {
   85     85   
                    builder.id = Some(deser.read_string(member)?);
   86     86   
                }
   87     87   
                Some(1) => {
   88     88   
                    builder.display_name = Some(deser.read_string(member)?);
   89     89   
                }
   90     90   
                _ => {}
   91     91   
            }
   92     92   
            Ok(())
   93     93   
        })?;
   94     94   
        Ok(builder.build())
   95     95   
    }
   96     96   
}
          97  +
impl Initiator {
          98  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          99  +
    pub fn deserialize_with_response(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         101  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         102  +
        _status: u16,
         103  +
        _body: &[u8],
         104  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         105  +
        Self::deserialize(deserializer)
         106  +
    }
         107  +
}
   97    108   
impl Initiator {
   98    109   
    /// Creates a new builder-style object to manufacture [`Initiator`](crate::types::Initiator).
   99    110   
    pub fn builder() -> crate::types::builders::InitiatorBuilder {
  100    111   
        crate::types::builders::InitiatorBuilder::default()
  101    112   
    }
  102    113   
}
  103    114   
  104    115   
/// A builder for [`Initiator`](crate::types::Initiator).
  105    116   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  106    117   
#[non_exhaustive]

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

@@ -9,9 +163,174 @@
   29     29   
    /// <p>Specifies Parquet as object's input serialization format.</p>
   30     30   
    pub fn parquet(&self) -> ::std::option::Option<&crate::types::ParquetInput> {
   31     31   
        self.parquet.as_ref()
   32     32   
    }
   33     33   
}
   34     34   
static INPUTSERIALIZATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   35     35   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InputSerialization", "com.amazonaws.s3", "InputSerialization");
   36     36   
static INPUTSERIALIZATION_MEMBER_CSV: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InputSerialization$CSV", "com.amazonaws.s3", "InputSerialization"),
   38     38   
    ::aws_smithy_schema::ShapeType::Structure,
   39         -
    "csv",
          39  +
    "CSV",
   40     40   
    0,
   41     41   
);
   42     42   
static INPUTSERIALIZATION_MEMBER_COMPRESSION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.s3#InputSerialization$CompressionType",
   45     45   
        "com.amazonaws.s3",
   46     46   
        "InputSerialization",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "compression_type",
          49  +
    "CompressionType",
   50     50   
    1,
   51     51   
);
   52     52   
static INPUTSERIALIZATION_MEMBER_JSON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InputSerialization$JSON", "com.amazonaws.s3", "InputSerialization"),
   54     54   
    ::aws_smithy_schema::ShapeType::Structure,
   55         -
    "json",
          55  +
    "JSON",
   56     56   
    2,
   57     57   
);
   58     58   
static INPUTSERIALIZATION_MEMBER_PARQUET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InputSerialization$Parquet", "com.amazonaws.s3", "InputSerialization"),
   60     60   
    ::aws_smithy_schema::ShapeType::Structure,
   61         -
    "parquet",
          61  +
    "Parquet",
   62     62   
    3,
   63     63   
);
   64     64   
static INPUTSERIALIZATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   65     65   
    INPUTSERIALIZATION_SCHEMA_ID,
   66     66   
    ::aws_smithy_schema::ShapeType::Structure,
   67     67   
    &[
   68     68   
        &INPUTSERIALIZATION_MEMBER_CSV,
   69     69   
        &INPUTSERIALIZATION_MEMBER_COMPRESSION_TYPE,
   70     70   
        &INPUTSERIALIZATION_MEMBER_JSON,
   71     71   
        &INPUTSERIALIZATION_MEMBER_PARQUET,
   72     72   
    ],
   73     73   
);
   74     74   
impl InputSerialization {
   75     75   
    /// The schema for this shape.
   76     76   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INPUTSERIALIZATION_SCHEMA;
   77     77   
}
   78     78   
impl ::aws_smithy_schema::serde::SerializableStruct for InputSerialization {
   79     79   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   80     80   
    fn serialize_members(
   81     81   
        &self,
   82     82   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   83     83   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   84     84   
        if let Some(ref val) = self.csv {
   85     85   
            ser.write_struct(&INPUTSERIALIZATION_MEMBER_CSV, val)?;
   86     86   
        }
   87     87   
        if let Some(ref val) = self.compression_type {
   88     88   
            ser.write_string(&INPUTSERIALIZATION_MEMBER_COMPRESSION_TYPE, val.as_str())?;
   89     89   
        }
   90     90   
        if let Some(ref val) = self.json {
   91     91   
            ser.write_struct(&INPUTSERIALIZATION_MEMBER_JSON, val)?;
   92     92   
        }
   93     93   
        if let Some(ref val) = self.parquet {
   94     94   
            ser.write_struct(&INPUTSERIALIZATION_MEMBER_PARQUET, val)?;
   95     95   
        }
   96     96   
        Ok(())
   97     97   
    }
   98     98   
}
   99     99   
impl InputSerialization {
  100    100   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  101         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  102         -
        deserializer: &mut D,
         101  +
    pub fn deserialize(
         102  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  103    103   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  104    104   
        #[allow(unused_variables, unused_mut)]
  105    105   
        let mut builder = Self::builder();
  106    106   
        #[allow(
  107    107   
            unused_variables,
  108    108   
            unreachable_code,
  109    109   
            clippy::single_match,
  110    110   
            clippy::match_single_binding,
  111    111   
            clippy::diverging_sub_expression
  112    112   
        )]
  113         -
        deserializer.read_struct(&INPUTSERIALIZATION_SCHEMA, (), |_, member, deser| {
         113  +
        deserializer.read_struct(&INPUTSERIALIZATION_SCHEMA, &mut |member, deser| {
  114    114   
            match member.member_index() {
  115    115   
                Some(0) => {
  116    116   
                    builder.csv = Some(crate::types::CsvInput::deserialize(deser)?);
  117    117   
                }
  118    118   
                Some(1) => {
  119    119   
                    builder.compression_type = Some(crate::types::CompressionType::from(deser.read_string(member)?.as_str()));
  120    120   
                }
  121    121   
                Some(2) => {
  122    122   
                    builder.json = Some(crate::types::JsonInput::deserialize(deser)?);
  123    123   
                }
  124    124   
                Some(3) => {
  125    125   
                    builder.parquet = Some(crate::types::ParquetInput::deserialize(deser)?);
  126    126   
                }
  127    127   
                _ => {}
  128    128   
            }
  129    129   
            Ok(())
  130    130   
        })?;
  131    131   
        Ok(builder.build())
  132    132   
    }
  133    133   
}
         134  +
impl InputSerialization {
         135  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         136  +
    pub fn deserialize_with_response(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         138  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         139  +
        _status: u16,
         140  +
        _body: &[u8],
         141  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         142  +
        Self::deserialize(deserializer)
         143  +
    }
         144  +
}
  134    145   
impl InputSerialization {
  135    146   
    /// Creates a new builder-style object to manufacture [`InputSerialization`](crate::types::InputSerialization).
  136    147   
    pub fn builder() -> crate::types::builders::InputSerializationBuilder {
  137    148   
        crate::types::builders::InputSerializationBuilder::default()
  138    149   
    }
  139    150   
}
  140    151   
  141    152   
/// A builder for [`InputSerialization`](crate::types::InputSerialization).
  142    153   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  143    154   
#[non_exhaustive]

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

@@ -6,6 +151,159 @@
   26     26   
    "com.amazonaws.s3",
   27     27   
    "IntelligentTieringAndOperator",
   28     28   
);
   29     29   
static INTELLIGENTTIERINGANDOPERATOR_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static(
   31     31   
        "com.amazonaws.s3#IntelligentTieringAndOperator$Prefix",
   32     32   
        "com.amazonaws.s3",
   33     33   
        "IntelligentTieringAndOperator",
   34     34   
    ),
   35     35   
    ::aws_smithy_schema::ShapeType::String,
   36         -
    "prefix",
          36  +
    "Prefix",
   37     37   
    0,
   38     38   
);
   39     39   
static INTELLIGENTTIERINGANDOPERATOR_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.s3#IntelligentTieringAndOperator$Tags",
   42     42   
        "com.amazonaws.s3",
   43     43   
        "IntelligentTieringAndOperator",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::List,
   46         -
    "tags",
          46  +
    "Tags",
   47     47   
    1,
   48     48   
)
   49     49   
.with_xml_name("Tag")
   50     50   
.with_xml_flattened();
   51     51   
static INTELLIGENTTIERINGANDOPERATOR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   52     52   
    INTELLIGENTTIERINGANDOPERATOR_SCHEMA_ID,
   53     53   
    ::aws_smithy_schema::ShapeType::Structure,
   54     54   
    &[&INTELLIGENTTIERINGANDOPERATOR_MEMBER_PREFIX, &INTELLIGENTTIERINGANDOPERATOR_MEMBER_TAGS],
   55     55   
);
   56     56   
impl IntelligentTieringAndOperator {
   57     57   
    /// The schema for this shape.
   58     58   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INTELLIGENTTIERINGANDOPERATOR_SCHEMA;
   59     59   
}
   60     60   
impl ::aws_smithy_schema::serde::SerializableStruct for IntelligentTieringAndOperator {
   61     61   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   62     62   
    fn serialize_members(
   63     63   
        &self,
   64     64   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   65     65   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   66     66   
        if let Some(ref val) = self.prefix {
   67     67   
            ser.write_string(&INTELLIGENTTIERINGANDOPERATOR_MEMBER_PREFIX, val)?;
   68     68   
        }
   69     69   
        if let Some(ref val) = self.tags {
   70     70   
            ser.write_list(
   71     71   
                &INTELLIGENTTIERINGANDOPERATOR_MEMBER_TAGS,
   72     72   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   73     73   
                    for item in val {
   74     74   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
   75     75   
                    }
   76     76   
                    Ok(())
   77     77   
                },
   78     78   
            )?;
   79     79   
        }
   80     80   
        Ok(())
   81     81   
    }
   82     82   
}
   83     83   
impl IntelligentTieringAndOperator {
   84     84   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   85         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   86         -
        deserializer: &mut D,
          85  +
    pub fn deserialize(
          86  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   87     87   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   88     88   
        #[allow(unused_variables, unused_mut)]
   89     89   
        let mut builder = Self::builder();
   90     90   
        #[allow(
   91     91   
            unused_variables,
   92     92   
            unreachable_code,
   93     93   
            clippy::single_match,
   94     94   
            clippy::match_single_binding,
   95     95   
            clippy::diverging_sub_expression
   96     96   
        )]
   97         -
        deserializer.read_struct(&INTELLIGENTTIERINGANDOPERATOR_SCHEMA, (), |_, member, deser| {
          97  +
        deserializer.read_struct(&INTELLIGENTTIERINGANDOPERATOR_SCHEMA, &mut |member, deser| {
   98     98   
            match member.member_index() {
   99     99   
                Some(0) => {
  100    100   
                    builder.prefix = Some(deser.read_string(member)?);
  101    101   
                }
  102    102   
                Some(1) => {
  103    103   
                    builder.tags = Some({
  104         -
                        let container = if let Some(cap) = deser.container_size() {
  105         -
                            Vec::with_capacity(cap)
  106         -
                        } else {
  107         -
                            Vec::new()
  108         -
                        };
  109         -
                        deser.read_list(member, container, |mut list, deser| {
  110         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  111         -
                            Ok(list)
  112         -
                        })?
         104  +
                        let mut container = Vec::new();
         105  +
                        deser.read_list(member, &mut |deser| {
         106  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         107  +
                            Ok(())
         108  +
                        })?;
         109  +
                        container
  113    110   
                    });
  114    111   
                }
  115    112   
                _ => {}
  116    113   
            }
  117    114   
            Ok(())
  118    115   
        })?;
  119    116   
        Ok(builder.build())
  120    117   
    }
  121    118   
}
         119  +
impl IntelligentTieringAndOperator {
         120  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         121  +
    pub fn deserialize_with_response(
         122  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         123  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         124  +
        _status: u16,
         125  +
        _body: &[u8],
         126  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         127  +
        Self::deserialize(deserializer)
         128  +
    }
         129  +
}
  122    130   
impl IntelligentTieringAndOperator {
  123    131   
    /// Creates a new builder-style object to manufacture [`IntelligentTieringAndOperator`](crate::types::IntelligentTieringAndOperator).
  124    132   
    pub fn builder() -> crate::types::builders::IntelligentTieringAndOperatorBuilder {
  125    133   
        crate::types::builders::IntelligentTieringAndOperatorBuilder::default()
  126    134   
    }
  127    135   
}
  128    136   
  129    137   
/// A builder for [`IntelligentTieringAndOperator`](crate::types::IntelligentTieringAndOperator).
  130    138   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  131    139   
#[non_exhaustive]

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

@@ -19,19 +207,217 @@
   39     39   
    "com.amazonaws.s3",
   40     40   
    "IntelligentTieringConfiguration",
   41     41   
);
   42     42   
static INTELLIGENTTIERINGCONFIGURATION_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.s3#IntelligentTieringConfiguration$Id",
   45     45   
        "com.amazonaws.s3",
   46     46   
        "IntelligentTieringConfiguration",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "id",
          49  +
    "Id",
   50     50   
    0,
   51     51   
);
   52     52   
static INTELLIGENTTIERINGCONFIGURATION_MEMBER_FILTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.s3#IntelligentTieringConfiguration$Filter",
   55     55   
        "com.amazonaws.s3",
   56     56   
        "IntelligentTieringConfiguration",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::Structure,
   59         -
    "filter",
          59  +
    "Filter",
   60     60   
    1,
   61     61   
);
   62     62   
static INTELLIGENTTIERINGCONFIGURATION_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.s3#IntelligentTieringConfiguration$Status",
   65     65   
        "com.amazonaws.s3",
   66     66   
        "IntelligentTieringConfiguration",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "status",
          69  +
    "Status",
   70     70   
    2,
   71     71   
);
   72     72   
static INTELLIGENTTIERINGCONFIGURATION_MEMBER_TIERINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.s3#IntelligentTieringConfiguration$Tierings",
   75     75   
        "com.amazonaws.s3",
   76     76   
        "IntelligentTieringConfiguration",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::List,
   79         -
    "tierings",
          79  +
    "Tierings",
   80     80   
    3,
   81     81   
)
   82     82   
.with_xml_name("Tiering")
   83     83   
.with_xml_flattened();
   84     84   
static INTELLIGENTTIERINGCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   85     85   
    INTELLIGENTTIERINGCONFIGURATION_SCHEMA_ID,
   86     86   
    ::aws_smithy_schema::ShapeType::Structure,
   87     87   
    &[
   88     88   
        &INTELLIGENTTIERINGCONFIGURATION_MEMBER_ID,
   89     89   
        &INTELLIGENTTIERINGCONFIGURATION_MEMBER_FILTER,
   90     90   
        &INTELLIGENTTIERINGCONFIGURATION_MEMBER_STATUS,
   91     91   
        &INTELLIGENTTIERINGCONFIGURATION_MEMBER_TIERINGS,
   92     92   
    ],
   93     93   
);
   94     94   
impl IntelligentTieringConfiguration {
   95     95   
    /// The schema for this shape.
   96     96   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INTELLIGENTTIERINGCONFIGURATION_SCHEMA;
   97     97   
}
   98     98   
impl ::aws_smithy_schema::serde::SerializableStruct for IntelligentTieringConfiguration {
   99     99   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  100    100   
    fn serialize_members(
  101    101   
        &self,
  102    102   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  103    103   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  104    104   
        {
  105    105   
            let val = &self.id;
  106    106   
            ser.write_string(&INTELLIGENTTIERINGCONFIGURATION_MEMBER_ID, val)?;
  107    107   
        }
  108    108   
        if let Some(ref val) = self.filter {
  109    109   
            ser.write_struct(&INTELLIGENTTIERINGCONFIGURATION_MEMBER_FILTER, val)?;
  110    110   
        }
  111    111   
        {
  112    112   
            let val = &self.status;
  113    113   
            ser.write_string(&INTELLIGENTTIERINGCONFIGURATION_MEMBER_STATUS, val.as_str())?;
  114    114   
        }
  115    115   
        {
  116    116   
            let val = &self.tierings;
  117    117   
  118    118   
            ser.write_list(
  119    119   
                &INTELLIGENTTIERINGCONFIGURATION_MEMBER_TIERINGS,
  120    120   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  121    121   
                    for item in val {
  122    122   
                        ser.write_struct(crate::types::Tiering::SCHEMA, item)?;
  123    123   
                    }
  124    124   
                    Ok(())
  125    125   
                },
  126    126   
            )?;
  127    127   
        }
  128    128   
        Ok(())
  129    129   
    }
  130    130   
}
  131    131   
impl IntelligentTieringConfiguration {
  132    132   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  133         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  134         -
        deserializer: &mut D,
         133  +
    pub fn deserialize(
         134  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  135    135   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  136    136   
        #[allow(unused_variables, unused_mut)]
  137    137   
        let mut builder = Self::builder();
  138    138   
        #[allow(
  139    139   
            unused_variables,
  140    140   
            unreachable_code,
  141    141   
            clippy::single_match,
  142    142   
            clippy::match_single_binding,
  143    143   
            clippy::diverging_sub_expression
  144    144   
        )]
  145         -
        deserializer.read_struct(&INTELLIGENTTIERINGCONFIGURATION_SCHEMA, (), |_, member, deser| {
         145  +
        deserializer.read_struct(&INTELLIGENTTIERINGCONFIGURATION_SCHEMA, &mut |member, deser| {
  146    146   
            match member.member_index() {
  147    147   
                Some(0) => {
  148    148   
                    builder.id = Some(deser.read_string(member)?);
  149    149   
                }
  150    150   
                Some(1) => {
  151    151   
                    builder.filter = Some(crate::types::IntelligentTieringFilter::deserialize(deser)?);
  152    152   
                }
  153    153   
                Some(2) => {
  154    154   
                    builder.status = Some(crate::types::IntelligentTieringStatus::from(deser.read_string(member)?.as_str()));
  155    155   
                }
  156    156   
                Some(3) => {
  157    157   
                    builder.tierings = Some({
  158         -
                        let container = if let Some(cap) = deser.container_size() {
  159         -
                            Vec::with_capacity(cap)
  160         -
                        } else {
  161         -
                            Vec::new()
  162         -
                        };
  163         -
                        deser.read_list(member, container, |mut list, deser| {
  164         -
                            list.push(crate::types::Tiering::deserialize(deser)?);
  165         -
                            Ok(list)
  166         -
                        })?
         158  +
                        let mut container = Vec::new();
         159  +
                        deser.read_list(member, &mut |deser| {
         160  +
                            container.push(crate::types::Tiering::deserialize(deser)?);
         161  +
                            Ok(())
         162  +
                        })?;
         163  +
                        container
  167    164   
                    });
  168    165   
                }
  169    166   
                _ => {}
  170    167   
            }
  171    168   
            Ok(())
  172    169   
        })?;
         170  +
        builder.id = builder.id.or(Some(String::new()));
         171  +
        builder.tierings = builder.tierings.or(Some(Vec::new()));
  173    172   
        builder
  174    173   
            .build()
  175    174   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  176    175   
    }
  177    176   
}
         177  +
impl IntelligentTieringConfiguration {
         178  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         179  +
    pub fn deserialize_with_response(
         180  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         181  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         182  +
        _status: u16,
         183  +
        _body: &[u8],
         184  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         185  +
        Self::deserialize(deserializer)
         186  +
    }
         187  +
}
  178    188   
impl IntelligentTieringConfiguration {
  179    189   
    /// Creates a new builder-style object to manufacture [`IntelligentTieringConfiguration`](crate::types::IntelligentTieringConfiguration).
  180    190   
    pub fn builder() -> crate::types::builders::IntelligentTieringConfigurationBuilder {
  181    191   
        crate::types::builders::IntelligentTieringConfigurationBuilder::default()
  182    192   
    }
  183    193   
}
  184    194   
  185    195   
/// A builder for [`IntelligentTieringConfiguration`](crate::types::IntelligentTieringConfiguration).
  186    196   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  187    197   
#[non_exhaustive]

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

@@ -14,14 +159,170 @@
   34     34   
    "com.amazonaws.s3",
   35     35   
    "IntelligentTieringFilter",
   36     36   
);
   37     37   
static INTELLIGENTTIERINGFILTER_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.s3#IntelligentTieringFilter$Prefix",
   40     40   
        "com.amazonaws.s3",
   41     41   
        "IntelligentTieringFilter",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::String,
   44         -
    "prefix",
          44  +
    "Prefix",
   45     45   
    0,
   46     46   
);
   47     47   
static INTELLIGENTTIERINGFILTER_MEMBER_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   48     48   
    ::aws_smithy_schema::ShapeId::from_static(
   49     49   
        "com.amazonaws.s3#IntelligentTieringFilter$Tag",
   50     50   
        "com.amazonaws.s3",
   51     51   
        "IntelligentTieringFilter",
   52     52   
    ),
   53     53   
    ::aws_smithy_schema::ShapeType::Structure,
   54         -
    "tag",
          54  +
    "Tag",
   55     55   
    1,
   56     56   
);
   57     57   
static INTELLIGENTTIERINGFILTER_MEMBER_AND: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.s3#IntelligentTieringFilter$And",
   60     60   
        "com.amazonaws.s3",
   61     61   
        "IntelligentTieringFilter",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::Structure,
   64         -
    "and",
          64  +
    "And",
   65     65   
    2,
   66     66   
);
   67     67   
static INTELLIGENTTIERINGFILTER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   68     68   
    INTELLIGENTTIERINGFILTER_SCHEMA_ID,
   69     69   
    ::aws_smithy_schema::ShapeType::Structure,
   70     70   
    &[
   71     71   
        &INTELLIGENTTIERINGFILTER_MEMBER_PREFIX,
   72     72   
        &INTELLIGENTTIERINGFILTER_MEMBER_TAG,
   73     73   
        &INTELLIGENTTIERINGFILTER_MEMBER_AND,
   74     74   
    ],
   75     75   
);
   76     76   
impl IntelligentTieringFilter {
   77     77   
    /// The schema for this shape.
   78     78   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INTELLIGENTTIERINGFILTER_SCHEMA;
   79     79   
}
   80     80   
impl ::aws_smithy_schema::serde::SerializableStruct for IntelligentTieringFilter {
   81     81   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   82     82   
    fn serialize_members(
   83     83   
        &self,
   84     84   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   85     85   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   86     86   
        if let Some(ref val) = self.prefix {
   87     87   
            ser.write_string(&INTELLIGENTTIERINGFILTER_MEMBER_PREFIX, val)?;
   88     88   
        }
   89     89   
        if let Some(ref val) = self.tag {
   90     90   
            ser.write_struct(&INTELLIGENTTIERINGFILTER_MEMBER_TAG, val)?;
   91     91   
        }
   92     92   
        if let Some(ref val) = self.and {
   93     93   
            ser.write_struct(&INTELLIGENTTIERINGFILTER_MEMBER_AND, val)?;
   94     94   
        }
   95     95   
        Ok(())
   96     96   
    }
   97     97   
}
   98     98   
impl IntelligentTieringFilter {
   99     99   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  100         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  101         -
        deserializer: &mut D,
         100  +
    pub fn deserialize(
         101  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  102    102   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  103    103   
        #[allow(unused_variables, unused_mut)]
  104    104   
        let mut builder = Self::builder();
  105    105   
        #[allow(
  106    106   
            unused_variables,
  107    107   
            unreachable_code,
  108    108   
            clippy::single_match,
  109    109   
            clippy::match_single_binding,
  110    110   
            clippy::diverging_sub_expression
  111    111   
        )]
  112         -
        deserializer.read_struct(&INTELLIGENTTIERINGFILTER_SCHEMA, (), |_, member, deser| {
         112  +
        deserializer.read_struct(&INTELLIGENTTIERINGFILTER_SCHEMA, &mut |member, deser| {
  113    113   
            match member.member_index() {
  114    114   
                Some(0) => {
  115    115   
                    builder.prefix = Some(deser.read_string(member)?);
  116    116   
                }
  117    117   
                Some(1) => {
  118    118   
                    builder.tag = Some(crate::types::Tag::deserialize(deser)?);
  119    119   
                }
  120    120   
                Some(2) => {
  121    121   
                    builder.and = Some(crate::types::IntelligentTieringAndOperator::deserialize(deser)?);
  122    122   
                }
  123    123   
                _ => {}
  124    124   
            }
  125    125   
            Ok(())
  126    126   
        })?;
  127    127   
        Ok(builder.build())
  128    128   
    }
  129    129   
}
         130  +
impl IntelligentTieringFilter {
         131  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         132  +
    pub fn deserialize_with_response(
         133  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         134  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         135  +
        _status: u16,
         136  +
        _body: &[u8],
         137  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         138  +
        Self::deserialize(deserializer)
         139  +
    }
         140  +
}
  130    141   
impl IntelligentTieringFilter {
  131    142   
    /// Creates a new builder-style object to manufacture [`IntelligentTieringFilter`](crate::types::IntelligentTieringFilter).
  132    143   
    pub fn builder() -> crate::types::builders::IntelligentTieringFilterBuilder {
  133    144   
        crate::types::builders::IntelligentTieringFilterBuilder::default()
  134    145   
    }
  135    146   
}
  136    147   
  137    148   
/// A builder for [`IntelligentTieringFilter`](crate::types::IntelligentTieringFilter).
  138    149   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  139    150   
#[non_exhaustive]

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

@@ -34,34 +150,150 @@
   54     54   
}
   55     55   
static INVENTORYCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   56     56   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InventoryConfiguration", "com.amazonaws.s3", "InventoryConfiguration");
   57     57   
static INVENTORYCONFIGURATION_MEMBER_DESTINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.s3#InventoryConfiguration$Destination",
   60     60   
        "com.amazonaws.s3",
   61     61   
        "InventoryConfiguration",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::Structure,
   64         -
    "destination",
          64  +
    "Destination",
   65     65   
    0,
   66     66   
);
   67     67   
static INVENTORYCONFIGURATION_MEMBER_IS_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.s3#InventoryConfiguration$IsEnabled",
   70     70   
        "com.amazonaws.s3",
   71     71   
        "InventoryConfiguration",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::Boolean,
   74         -
    "is_enabled",
          74  +
    "IsEnabled",
   75     75   
    1,
   76     76   
);
   77     77   
static INVENTORYCONFIGURATION_MEMBER_FILTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.s3#InventoryConfiguration$Filter",
   80     80   
        "com.amazonaws.s3",
   81     81   
        "InventoryConfiguration",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::Structure,
   84         -
    "filter",
          84  +
    "Filter",
   85     85   
    2,
   86     86   
);
   87     87   
static INVENTORYCONFIGURATION_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InventoryConfiguration$Id", "com.amazonaws.s3", "InventoryConfiguration"),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "id",
          90  +
    "Id",
   91     91   
    3,
   92     92   
);
   93     93   
static INVENTORYCONFIGURATION_MEMBER_INCLUDED_OBJECT_VERSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.s3#InventoryConfiguration$IncludedObjectVersions",
   96     96   
        "com.amazonaws.s3",
   97     97   
        "InventoryConfiguration",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "included_object_versions",
         100  +
    "IncludedObjectVersions",
  101    101   
    4,
  102    102   
);
  103    103   
static INVENTORYCONFIGURATION_MEMBER_OPTIONAL_FIELDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.s3#InventoryConfiguration$OptionalFields",
  106    106   
        "com.amazonaws.s3",
  107    107   
        "InventoryConfiguration",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::List,
  110         -
    "optional_fields",
         110  +
    "OptionalFields",
  111    111   
    5,
  112    112   
);
  113    113   
static INVENTORYCONFIGURATION_MEMBER_SCHEDULE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static(
  115    115   
        "com.amazonaws.s3#InventoryConfiguration$Schedule",
  116    116   
        "com.amazonaws.s3",
  117    117   
        "InventoryConfiguration",
  118    118   
    ),
  119    119   
    ::aws_smithy_schema::ShapeType::Structure,
  120         -
    "schedule",
         120  +
    "Schedule",
  121    121   
    6,
  122    122   
);
  123    123   
static INVENTORYCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  124    124   
    INVENTORYCONFIGURATION_SCHEMA_ID,
  125    125   
    ::aws_smithy_schema::ShapeType::Structure,
  126    126   
    &[
  127    127   
        &INVENTORYCONFIGURATION_MEMBER_DESTINATION,
  128    128   
        &INVENTORYCONFIGURATION_MEMBER_IS_ENABLED,
  129    129   
        &INVENTORYCONFIGURATION_MEMBER_FILTER,
  130    130   
        &INVENTORYCONFIGURATION_MEMBER_ID,
@@ -153,153 +266,276 @@
  173    173   
            )?;
  174    174   
        }
  175    175   
        if let Some(ref val) = self.schedule {
  176    176   
            ser.write_struct(&INVENTORYCONFIGURATION_MEMBER_SCHEDULE, val)?;
  177    177   
        }
  178    178   
        Ok(())
  179    179   
    }
  180    180   
}
  181    181   
impl InventoryConfiguration {
  182    182   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  183         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  184         -
        deserializer: &mut D,
         183  +
    pub fn deserialize(
         184  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  185    185   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  186    186   
        #[allow(unused_variables, unused_mut)]
  187    187   
        let mut builder = Self::builder();
  188    188   
        #[allow(
  189    189   
            unused_variables,
  190    190   
            unreachable_code,
  191    191   
            clippy::single_match,
  192    192   
            clippy::match_single_binding,
  193    193   
            clippy::diverging_sub_expression
  194    194   
        )]
  195         -
        deserializer.read_struct(&INVENTORYCONFIGURATION_SCHEMA, (), |_, member, deser| {
         195  +
        deserializer.read_struct(&INVENTORYCONFIGURATION_SCHEMA, &mut |member, deser| {
  196    196   
            match member.member_index() {
  197    197   
                Some(0) => {
  198    198   
                    builder.destination = Some(crate::types::InventoryDestination::deserialize(deser)?);
  199    199   
                }
  200    200   
                Some(1) => {
  201    201   
                    builder.is_enabled = Some(deser.read_boolean(member)?);
  202    202   
                }
  203    203   
                Some(2) => {
  204    204   
                    builder.filter = Some(crate::types::InventoryFilter::deserialize(deser)?);
  205    205   
                }
  206    206   
                Some(3) => {
  207    207   
                    builder.id = Some(deser.read_string(member)?);
  208    208   
                }
  209    209   
                Some(4) => {
  210    210   
                    builder.included_object_versions = Some(crate::types::InventoryIncludedObjectVersions::from(deser.read_string(member)?.as_str()));
  211    211   
                }
  212    212   
                Some(5) => {
  213    213   
                    builder.optional_fields = Some({
  214         -
                        let container = if let Some(cap) = deser.container_size() {
  215         -
                            Vec::with_capacity(cap)
  216         -
                        } else {
  217         -
                            Vec::new()
  218         -
                        };
  219         -
                        deser.read_list(member, container, |mut list, deser| {
  220         -
                            list.push(crate::types::InventoryOptionalField::from(deser.read_string(member)?.as_str()));
  221         -
                            Ok(list)
  222         -
                        })?
         214  +
                        let mut container = Vec::new();
         215  +
                        deser.read_list(member, &mut |deser| {
         216  +
                            container.push(crate::types::InventoryOptionalField::from(deser.read_string(member)?.as_str()));
         217  +
                            Ok(())
         218  +
                        })?;
         219  +
                        container
  223    220   
                    });
  224    221   
                }
  225    222   
                Some(6) => {
  226    223   
                    builder.schedule = Some(crate::types::InventorySchedule::deserialize(deser)?);
  227    224   
                }
  228    225   
                _ => {}
  229    226   
            }
  230    227   
            Ok(())
  231    228   
        })?;
         229  +
        builder.is_enabled = builder.is_enabled.or(Some(false));
         230  +
        builder.id = builder.id.or(Some(String::new()));
  232    231   
        builder
  233    232   
            .build()
  234    233   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  235    234   
    }
  236    235   
}
         236  +
impl InventoryConfiguration {
         237  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         238  +
    pub fn deserialize_with_response(
         239  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         240  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         241  +
        _status: u16,
         242  +
        _body: &[u8],
         243  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         244  +
        Self::deserialize(deserializer)
         245  +
    }
         246  +
}
  237    247   
impl InventoryConfiguration {
  238    248   
    /// Creates a new builder-style object to manufacture [`InventoryConfiguration`](crate::types::InventoryConfiguration).
  239    249   
    pub fn builder() -> crate::types::builders::InventoryConfigurationBuilder {
  240    250   
        crate::types::builders::InventoryConfigurationBuilder::default()
  241    251   
    }
  242    252   
}
  243    253   
  244    254   
/// A builder for [`InventoryConfiguration`](crate::types::InventoryConfiguration).
  245    255   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  246    256   
#[non_exhaustive]

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

@@ -1,1 +104,115 @@
   15     15   
}
   16     16   
static INVENTORYDESTINATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InventoryDestination", "com.amazonaws.s3", "InventoryDestination");
   18     18   
static INVENTORYDESTINATION_MEMBER_S3_BUCKET_DESTINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static(
   20     20   
        "com.amazonaws.s3#InventoryDestination$S3BucketDestination",
   21     21   
        "com.amazonaws.s3",
   22     22   
        "InventoryDestination",
   23     23   
    ),
   24     24   
    ::aws_smithy_schema::ShapeType::Structure,
   25         -
    "s3_bucket_destination",
          25  +
    "S3BucketDestination",
   26     26   
    0,
   27     27   
);
   28     28   
static INVENTORYDESTINATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   29     29   
    INVENTORYDESTINATION_SCHEMA_ID,
   30     30   
    ::aws_smithy_schema::ShapeType::Structure,
   31     31   
    &[&INVENTORYDESTINATION_MEMBER_S3_BUCKET_DESTINATION],
   32     32   
);
   33     33   
impl InventoryDestination {
   34     34   
    /// The schema for this shape.
   35     35   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVENTORYDESTINATION_SCHEMA;
   36     36   
}
   37     37   
impl ::aws_smithy_schema::serde::SerializableStruct for InventoryDestination {
   38     38   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   39     39   
    fn serialize_members(
   40     40   
        &self,
   41     41   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   42     42   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   43     43   
        if let Some(ref val) = self.s3_bucket_destination {
   44     44   
            ser.write_struct(&INVENTORYDESTINATION_MEMBER_S3_BUCKET_DESTINATION, val)?;
   45     45   
        }
   46     46   
        Ok(())
   47     47   
    }
   48     48   
}
   49     49   
impl InventoryDestination {
   50     50   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   51         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   52         -
        deserializer: &mut D,
          51  +
    pub fn deserialize(
          52  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   53     53   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   54     54   
        #[allow(unused_variables, unused_mut)]
   55     55   
        let mut builder = Self::builder();
   56     56   
        #[allow(
   57     57   
            unused_variables,
   58     58   
            unreachable_code,
   59     59   
            clippy::single_match,
   60     60   
            clippy::match_single_binding,
   61     61   
            clippy::diverging_sub_expression
   62     62   
        )]
   63         -
        deserializer.read_struct(&INVENTORYDESTINATION_SCHEMA, (), |_, member, deser| {
          63  +
        deserializer.read_struct(&INVENTORYDESTINATION_SCHEMA, &mut |member, deser| {
   64     64   
            match member.member_index() {
   65     65   
                Some(0) => {
   66     66   
                    builder.s3_bucket_destination = Some(crate::types::InventoryS3BucketDestination::deserialize(deser)?);
   67     67   
                }
   68     68   
                _ => {}
   69     69   
            }
   70     70   
            Ok(())
   71     71   
        })?;
   72     72   
        Ok(builder.build())
   73     73   
    }
   74     74   
}
          75  +
impl InventoryDestination {
          76  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          77  +
    pub fn deserialize_with_response(
          78  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          79  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          80  +
        _status: u16,
          81  +
        _body: &[u8],
          82  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          83  +
        Self::deserialize(deserializer)
          84  +
    }
          85  +
}
   75     86   
impl InventoryDestination {
   76     87   
    /// Creates a new builder-style object to manufacture [`InventoryDestination`](crate::types::InventoryDestination).
   77     88   
    pub fn builder() -> crate::types::builders::InventoryDestinationBuilder {
   78     89   
        crate::types::builders::InventoryDestinationBuilder::default()
   79     90   
    }
   80     91   
}
   81     92   
   82     93   
/// A builder for [`InventoryDestination`](crate::types::InventoryDestination).
   83     94   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   84     95   
#[non_exhaustive]

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

@@ -1,1 +120,131 @@
   17     17   
    /// <p>Specifies the use of SSE-KMS to encrypt delivered inventory reports.</p>
   18     18   
    pub fn ssekms(&self) -> ::std::option::Option<&crate::types::Ssekms> {
   19     19   
        self.ssekms.as_ref()
   20     20   
    }
   21     21   
}
   22     22   
static INVENTORYENCRYPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InventoryEncryption", "com.amazonaws.s3", "InventoryEncryption");
   24     24   
static INVENTORYENCRYPTION_MEMBER_SSES3: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InventoryEncryption$SSES3", "com.amazonaws.s3", "InventoryEncryption"),
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27         -
    "sses3",
          27  +
    "SSES3",
   28     28   
    0,
   29     29   
)
   30     30   
.with_xml_name("SSE-S3");
   31     31   
static INVENTORYENCRYPTION_MEMBER_SSEKMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InventoryEncryption$SSEKMS", "com.amazonaws.s3", "InventoryEncryption"),
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34         -
    "ssekms",
          34  +
    "SSEKMS",
   35     35   
    1,
   36     36   
)
   37     37   
.with_xml_name("SSE-KMS");
   38     38   
static INVENTORYENCRYPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    INVENTORYENCRYPTION_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&INVENTORYENCRYPTION_MEMBER_SSES3, &INVENTORYENCRYPTION_MEMBER_SSEKMS],
   42     42   
);
   43     43   
impl InventoryEncryption {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVENTORYENCRYPTION_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for InventoryEncryption {
   48     48   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   49     49   
    fn serialize_members(
   50     50   
        &self,
   51     51   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   52     52   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   53     53   
        if let Some(ref val) = self.sses3 {
   54     54   
            ser.write_struct(&INVENTORYENCRYPTION_MEMBER_SSES3, val)?;
   55     55   
        }
   56     56   
        if let Some(ref val) = self.ssekms {
   57     57   
            ser.write_struct(&INVENTORYENCRYPTION_MEMBER_SSEKMS, val)?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl InventoryEncryption {
   63     63   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   64         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   65         -
        deserializer: &mut D,
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   66     66   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        #[allow(unused_variables, unused_mut)]
   68     68   
        let mut builder = Self::builder();
   69     69   
        #[allow(
   70     70   
            unused_variables,
   71     71   
            unreachable_code,
   72     72   
            clippy::single_match,
   73     73   
            clippy::match_single_binding,
   74     74   
            clippy::diverging_sub_expression
   75     75   
        )]
   76         -
        deserializer.read_struct(&INVENTORYENCRYPTION_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&INVENTORYENCRYPTION_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.sses3 = Some(crate::types::Sses3::deserialize(deser)?);
   80     80   
                }
   81     81   
                Some(1) => {
   82     82   
                    builder.ssekms = Some(crate::types::Ssekms::deserialize(deser)?);
   83     83   
                }
   84     84   
                _ => {}
   85     85   
            }
   86     86   
            Ok(())
   87     87   
        })?;
   88     88   
        Ok(builder.build())
   89     89   
    }
   90     90   
}
          91  +
impl InventoryEncryption {
          92  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          93  +
    pub fn deserialize_with_response(
          94  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          95  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          96  +
        _status: u16,
          97  +
        _body: &[u8],
          98  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          99  +
        Self::deserialize(deserializer)
         100  +
    }
         101  +
}
   91    102   
impl InventoryEncryption {
   92    103   
    /// Creates a new builder-style object to manufacture [`InventoryEncryption`](crate::types::InventoryEncryption).
   93    104   
    pub fn builder() -> crate::types::builders::InventoryEncryptionBuilder {
   94    105   
        crate::types::builders::InventoryEncryptionBuilder::default()
   95    106   
    }
   96    107   
}
   97    108   
   98    109   
/// A builder for [`InventoryEncryption`](crate::types::InventoryEncryption).
   99    110   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  100    111   
#[non_exhaustive]

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

@@ -1,1 +104,116 @@
   12     12   
    pub fn prefix(&self) -> &str {
   13     13   
        use std::ops::Deref;
   14     14   
        self.prefix.deref()
   15     15   
    }
   16     16   
}
   17     17   
static INVENTORYFILTER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   18     18   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InventoryFilter", "com.amazonaws.s3", "InventoryFilter");
   19     19   
static INVENTORYFILTER_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   20     20   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InventoryFilter$Prefix", "com.amazonaws.s3", "InventoryFilter"),
   21     21   
    ::aws_smithy_schema::ShapeType::String,
   22         -
    "prefix",
          22  +
    "Prefix",
   23     23   
    0,
   24     24   
);
   25     25   
static INVENTORYFILTER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   26     26   
    INVENTORYFILTER_SCHEMA_ID,
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28     28   
    &[&INVENTORYFILTER_MEMBER_PREFIX],
   29     29   
);
   30     30   
impl InventoryFilter {
   31     31   
    /// The schema for this shape.
   32     32   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVENTORYFILTER_SCHEMA;
   33     33   
}
   34     34   
impl ::aws_smithy_schema::serde::SerializableStruct for InventoryFilter {
   35     35   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   36     36   
    fn serialize_members(
   37     37   
        &self,
   38     38   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   39     39   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   40     40   
        {
   41     41   
            let val = &self.prefix;
   42     42   
            ser.write_string(&INVENTORYFILTER_MEMBER_PREFIX, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl InventoryFilter {
   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(&INVENTORYFILTER_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&INVENTORYFILTER_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.prefix = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
          70  +
        builder.prefix = builder.prefix.or(Some(String::new()));
   70     71   
        builder
   71     72   
            .build()
   72     73   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   73     74   
    }
   74     75   
}
          76  +
impl InventoryFilter {
          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  +
}
   75     87   
impl InventoryFilter {
   76     88   
    /// Creates a new builder-style object to manufacture [`InventoryFilter`](crate::types::InventoryFilter).
   77     89   
    pub fn builder() -> crate::types::builders::InventoryFilterBuilder {
   78     90   
        crate::types::builders::InventoryFilterBuilder::default()
   79     91   
    }
   80     92   
}
   81     93   
   82     94   
/// A builder for [`InventoryFilter`](crate::types::InventoryFilter).
   83     95   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   84     96   
#[non_exhaustive]

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

@@ -27,27 +210,222 @@
   47     47   
    "com.amazonaws.s3",
   48     48   
    "InventoryS3BucketDestination",
   49     49   
);
   50     50   
static INVENTORYS3BUCKETDESTINATION_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.s3#InventoryS3BucketDestination$AccountId",
   53     53   
        "com.amazonaws.s3",
   54     54   
        "InventoryS3BucketDestination",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "account_id",
          57  +
    "AccountId",
   58     58   
    0,
   59     59   
);
   60     60   
static INVENTORYS3BUCKETDESTINATION_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.s3#InventoryS3BucketDestination$Bucket",
   63     63   
        "com.amazonaws.s3",
   64     64   
        "InventoryS3BucketDestination",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::String,
   67         -
    "bucket",
          67  +
    "Bucket",
   68     68   
    1,
   69     69   
);
   70     70   
static INVENTORYS3BUCKETDESTINATION_MEMBER_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.s3#InventoryS3BucketDestination$Format",
   73     73   
        "com.amazonaws.s3",
   74     74   
        "InventoryS3BucketDestination",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "format",
          77  +
    "Format",
   78     78   
    2,
   79     79   
);
   80     80   
static INVENTORYS3BUCKETDESTINATION_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static(
   82     82   
        "com.amazonaws.s3#InventoryS3BucketDestination$Prefix",
   83     83   
        "com.amazonaws.s3",
   84     84   
        "InventoryS3BucketDestination",
   85     85   
    ),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "prefix",
          87  +
    "Prefix",
   88     88   
    3,
   89     89   
);
   90     90   
static INVENTORYS3BUCKETDESTINATION_MEMBER_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.s3#InventoryS3BucketDestination$Encryption",
   93     93   
        "com.amazonaws.s3",
   94     94   
        "InventoryS3BucketDestination",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::Structure,
   97         -
    "encryption",
          97  +
    "Encryption",
   98     98   
    4,
   99     99   
);
  100    100   
static INVENTORYS3BUCKETDESTINATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  101    101   
    INVENTORYS3BUCKETDESTINATION_SCHEMA_ID,
  102    102   
    ::aws_smithy_schema::ShapeType::Structure,
  103    103   
    &[
  104    104   
        &INVENTORYS3BUCKETDESTINATION_MEMBER_ACCOUNT_ID,
  105    105   
        &INVENTORYS3BUCKETDESTINATION_MEMBER_BUCKET,
  106    106   
        &INVENTORYS3BUCKETDESTINATION_MEMBER_FORMAT,
  107    107   
        &INVENTORYS3BUCKETDESTINATION_MEMBER_PREFIX,
  108    108   
        &INVENTORYS3BUCKETDESTINATION_MEMBER_ENCRYPTION,
  109    109   
    ],
  110    110   
);
  111    111   
impl InventoryS3BucketDestination {
  112    112   
    /// The schema for this shape.
  113    113   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVENTORYS3BUCKETDESTINATION_SCHEMA;
  114    114   
}
  115    115   
impl ::aws_smithy_schema::serde::SerializableStruct for InventoryS3BucketDestination {
  116    116   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  117    117   
    fn serialize_members(
  118    118   
        &self,
  119    119   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  120    120   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  121    121   
        if let Some(ref val) = self.account_id {
  122    122   
            ser.write_string(&INVENTORYS3BUCKETDESTINATION_MEMBER_ACCOUNT_ID, val)?;
  123    123   
        }
  124    124   
        {
  125    125   
            let val = &self.bucket;
  126    126   
            ser.write_string(&INVENTORYS3BUCKETDESTINATION_MEMBER_BUCKET, val)?;
  127    127   
        }
  128    128   
        {
  129    129   
            let val = &self.format;
  130    130   
            ser.write_string(&INVENTORYS3BUCKETDESTINATION_MEMBER_FORMAT, val.as_str())?;
  131    131   
        }
  132    132   
        if let Some(ref val) = self.prefix {
  133    133   
            ser.write_string(&INVENTORYS3BUCKETDESTINATION_MEMBER_PREFIX, val)?;
  134    134   
        }
  135    135   
        if let Some(ref val) = self.encryption {
  136    136   
            ser.write_struct(&INVENTORYS3BUCKETDESTINATION_MEMBER_ENCRYPTION, val)?;
  137    137   
        }
  138    138   
        Ok(())
  139    139   
    }
  140    140   
}
  141    141   
impl InventoryS3BucketDestination {
  142    142   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  143         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  144         -
        deserializer: &mut D,
         143  +
    pub fn deserialize(
         144  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  145    145   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  146    146   
        #[allow(unused_variables, unused_mut)]
  147    147   
        let mut builder = Self::builder();
  148    148   
        #[allow(
  149    149   
            unused_variables,
  150    150   
            unreachable_code,
  151    151   
            clippy::single_match,
  152    152   
            clippy::match_single_binding,
  153    153   
            clippy::diverging_sub_expression
  154    154   
        )]
  155         -
        deserializer.read_struct(&INVENTORYS3BUCKETDESTINATION_SCHEMA, (), |_, member, deser| {
         155  +
        deserializer.read_struct(&INVENTORYS3BUCKETDESTINATION_SCHEMA, &mut |member, deser| {
  156    156   
            match member.member_index() {
  157    157   
                Some(0) => {
  158    158   
                    builder.account_id = Some(deser.read_string(member)?);
  159    159   
                }
  160    160   
                Some(1) => {
  161    161   
                    builder.bucket = Some(deser.read_string(member)?);
  162    162   
                }
  163    163   
                Some(2) => {
  164    164   
                    builder.format = Some(crate::types::InventoryFormat::from(deser.read_string(member)?.as_str()));
  165    165   
                }
  166    166   
                Some(3) => {
  167    167   
                    builder.prefix = Some(deser.read_string(member)?);
  168    168   
                }
  169    169   
                Some(4) => {
  170    170   
                    builder.encryption = Some(crate::types::InventoryEncryption::deserialize(deser)?);
  171    171   
                }
  172    172   
                _ => {}
  173    173   
            }
  174    174   
            Ok(())
  175    175   
        })?;
         176  +
        builder.bucket = builder.bucket.or(Some(String::new()));
  176    177   
        builder
  177    178   
            .build()
  178    179   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  179    180   
    }
  180    181   
}
         182  +
impl InventoryS3BucketDestination {
         183  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         184  +
    pub fn deserialize_with_response(
         185  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         186  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         187  +
        _status: u16,
         188  +
        _body: &[u8],
         189  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         190  +
        Self::deserialize(deserializer)
         191  +
    }
         192  +
}
  181    193   
impl InventoryS3BucketDestination {
  182    194   
    /// Creates a new builder-style object to manufacture [`InventoryS3BucketDestination`](crate::types::InventoryS3BucketDestination).
  183    195   
    pub fn builder() -> crate::types::builders::InventoryS3BucketDestinationBuilder {
  184    196   
        crate::types::builders::InventoryS3BucketDestinationBuilder::default()
  185    197   
    }
  186    198   
}
  187    199   
  188    200   
/// A builder for [`InventoryS3BucketDestination`](crate::types::InventoryS3BucketDestination).
  189    201   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  190    202   
#[non_exhaustive]

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

@@ -1,1 +103,114 @@
   11     11   
    /// <p>Specifies how frequently inventory results are produced.</p>
   12     12   
    pub fn frequency(&self) -> &crate::types::InventoryFrequency {
   13     13   
        &self.frequency
   14     14   
    }
   15     15   
}
   16     16   
static INVENTORYSCHEDULE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InventorySchedule", "com.amazonaws.s3", "InventorySchedule");
   18     18   
static INVENTORYSCHEDULE_MEMBER_FREQUENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InventorySchedule$Frequency", "com.amazonaws.s3", "InventorySchedule"),
   20     20   
    ::aws_smithy_schema::ShapeType::String,
   21         -
    "frequency",
          21  +
    "Frequency",
   22     22   
    0,
   23     23   
);
   24     24   
static INVENTORYSCHEDULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   25     25   
    INVENTORYSCHEDULE_SCHEMA_ID,
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    &[&INVENTORYSCHEDULE_MEMBER_FREQUENCY],
   28     28   
);
   29     29   
impl InventorySchedule {
   30     30   
    /// The schema for this shape.
   31     31   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVENTORYSCHEDULE_SCHEMA;
   32     32   
}
   33     33   
impl ::aws_smithy_schema::serde::SerializableStruct for InventorySchedule {
   34     34   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   35     35   
    fn serialize_members(
   36     36   
        &self,
   37     37   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   38     38   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   39     39   
        {
   40     40   
            let val = &self.frequency;
   41     41   
            ser.write_string(&INVENTORYSCHEDULE_MEMBER_FREQUENCY, val.as_str())?;
   42     42   
        }
   43     43   
        Ok(())
   44     44   
    }
   45     45   
}
   46     46   
impl InventorySchedule {
   47     47   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   48         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   49         -
        deserializer: &mut D,
          48  +
    pub fn deserialize(
          49  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   50     50   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   51     51   
        #[allow(unused_variables, unused_mut)]
   52     52   
        let mut builder = Self::builder();
   53     53   
        #[allow(
   54     54   
            unused_variables,
   55     55   
            unreachable_code,
   56     56   
            clippy::single_match,
   57     57   
            clippy::match_single_binding,
   58     58   
            clippy::diverging_sub_expression
   59     59   
        )]
   60         -
        deserializer.read_struct(&INVENTORYSCHEDULE_SCHEMA, (), |_, member, deser| {
          60  +
        deserializer.read_struct(&INVENTORYSCHEDULE_SCHEMA, &mut |member, deser| {
   61     61   
            match member.member_index() {
   62     62   
                Some(0) => {
   63     63   
                    builder.frequency = Some(crate::types::InventoryFrequency::from(deser.read_string(member)?.as_str()));
   64     64   
                }
   65     65   
                _ => {}
   66     66   
            }
   67     67   
            Ok(())
   68     68   
        })?;
   69     69   
        builder
   70     70   
            .build()
   71     71   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   72     72   
    }
   73     73   
}
          74  +
impl InventorySchedule {
          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 InventorySchedule {
   75     86   
    /// Creates a new builder-style object to manufacture [`InventorySchedule`](crate::types::InventorySchedule).
   76     87   
    pub fn builder() -> crate::types::builders::InventoryScheduleBuilder {
   77     88   
        crate::types::builders::InventoryScheduleBuilder::default()
   78     89   
    }
   79     90   
}
   80     91   
   81     92   
/// A builder for [`InventorySchedule`](crate::types::InventorySchedule).
   82     93   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   83     94   
#[non_exhaustive]

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

@@ -4,4 +135,146 @@
   24     24   
    "com.amazonaws.s3",
   25     25   
    "InventoryTableConfiguration",
   26     26   
);
   27     27   
static INVENTORYTABLECONFIGURATION_MEMBER_CONFIGURATION_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.s3#InventoryTableConfiguration$ConfigurationState",
   30     30   
        "com.amazonaws.s3",
   31     31   
        "InventoryTableConfiguration",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "configuration_state",
          34  +
    "ConfigurationState",
   35     35   
    0,
   36     36   
);
   37     37   
static INVENTORYTABLECONFIGURATION_MEMBER_ENCRYPTION_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.s3#InventoryTableConfiguration$EncryptionConfiguration",
   40     40   
        "com.amazonaws.s3",
   41     41   
        "InventoryTableConfiguration",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Structure,
   44         -
    "encryption_configuration",
          44  +
    "EncryptionConfiguration",
   45     45   
    1,
   46     46   
);
   47     47   
static INVENTORYTABLECONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    INVENTORYTABLECONFIGURATION_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[
   51     51   
        &INVENTORYTABLECONFIGURATION_MEMBER_CONFIGURATION_STATE,
   52     52   
        &INVENTORYTABLECONFIGURATION_MEMBER_ENCRYPTION_CONFIGURATION,
   53     53   
    ],
   54     54   
);
   55     55   
impl InventoryTableConfiguration {
   56     56   
    /// The schema for this shape.
   57     57   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVENTORYTABLECONFIGURATION_SCHEMA;
   58     58   
}
   59     59   
impl ::aws_smithy_schema::serde::SerializableStruct for InventoryTableConfiguration {
   60     60   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   61     61   
    fn serialize_members(
   62     62   
        &self,
   63     63   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   64     64   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   65     65   
        {
   66     66   
            let val = &self.configuration_state;
   67     67   
            ser.write_string(&INVENTORYTABLECONFIGURATION_MEMBER_CONFIGURATION_STATE, val.as_str())?;
   68     68   
        }
   69     69   
        if let Some(ref val) = self.encryption_configuration {
   70     70   
            ser.write_struct(&INVENTORYTABLECONFIGURATION_MEMBER_ENCRYPTION_CONFIGURATION, val)?;
   71     71   
        }
   72     72   
        Ok(())
   73     73   
    }
   74     74   
}
   75     75   
impl InventoryTableConfiguration {
   76     76   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   77         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   78         -
        deserializer: &mut D,
          77  +
    pub fn deserialize(
          78  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   79     79   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   80     80   
        #[allow(unused_variables, unused_mut)]
   81     81   
        let mut builder = Self::builder();
   82     82   
        #[allow(
   83     83   
            unused_variables,
   84     84   
            unreachable_code,
   85     85   
            clippy::single_match,
   86     86   
            clippy::match_single_binding,
   87     87   
            clippy::diverging_sub_expression
   88     88   
        )]
   89         -
        deserializer.read_struct(&INVENTORYTABLECONFIGURATION_SCHEMA, (), |_, member, deser| {
          89  +
        deserializer.read_struct(&INVENTORYTABLECONFIGURATION_SCHEMA, &mut |member, deser| {
   90     90   
            match member.member_index() {
   91     91   
                Some(0) => {
   92     92   
                    builder.configuration_state = Some(crate::types::InventoryConfigurationState::from(deser.read_string(member)?.as_str()));
   93     93   
                }
   94     94   
                Some(1) => {
   95     95   
                    builder.encryption_configuration = Some(crate::types::MetadataTableEncryptionConfiguration::deserialize(deser)?);
   96     96   
                }
   97     97   
                _ => {}
   98     98   
            }
   99     99   
            Ok(())
  100    100   
        })?;
  101    101   
        builder
  102    102   
            .build()
  103    103   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  104    104   
    }
  105    105   
}
         106  +
impl InventoryTableConfiguration {
         107  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         108  +
    pub fn deserialize_with_response(
         109  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         110  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         111  +
        _status: u16,
         112  +
        _body: &[u8],
         113  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         114  +
        Self::deserialize(deserializer)
         115  +
    }
         116  +
}
  106    117   
impl InventoryTableConfiguration {
  107    118   
    /// Creates a new builder-style object to manufacture [`InventoryTableConfiguration`](crate::types::InventoryTableConfiguration).
  108    119   
    pub fn builder() -> crate::types::builders::InventoryTableConfigurationBuilder {
  109    120   
        crate::types::builders::InventoryTableConfigurationBuilder::default()
  110    121   
    }
  111    122   
}
  112    123   
  113    124   
/// A builder for [`InventoryTableConfiguration`](crate::types::InventoryTableConfiguration).
  114    125   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  115    126   
#[non_exhaustive]

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

@@ -46,46 +228,239 @@
   66     66   
    "com.amazonaws.s3",
   67     67   
    "InventoryTableConfigurationResult",
   68     68   
);
   69     69   
static INVENTORYTABLECONFIGURATIONRESULT_MEMBER_CONFIGURATION_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.s3#InventoryTableConfigurationResult$ConfigurationState",
   72     72   
        "com.amazonaws.s3",
   73     73   
        "InventoryTableConfigurationResult",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "configuration_state",
          76  +
    "ConfigurationState",
   77     77   
    0,
   78     78   
);
   79     79   
static INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.s3#InventoryTableConfigurationResult$TableStatus",
   82     82   
        "com.amazonaws.s3",
   83     83   
        "InventoryTableConfigurationResult",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86         -
    "table_status",
          86  +
    "TableStatus",
   87     87   
    1,
   88     88   
);
   89     89   
static INVENTORYTABLECONFIGURATIONRESULT_MEMBER_ERROR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.s3#InventoryTableConfigurationResult$Error",
   92     92   
        "com.amazonaws.s3",
   93     93   
        "InventoryTableConfigurationResult",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::Structure,
   96         -
    "error",
          96  +
    "Error",
   97     97   
    2,
   98     98   
);
   99     99   
static INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.s3#InventoryTableConfigurationResult$TableName",
  102    102   
        "com.amazonaws.s3",
  103    103   
        "InventoryTableConfigurationResult",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::String,
  106         -
    "table_name",
         106  +
    "TableName",
  107    107   
    3,
  108    108   
);
  109    109   
static INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.s3#InventoryTableConfigurationResult$TableArn",
  112    112   
        "com.amazonaws.s3",
  113    113   
        "InventoryTableConfigurationResult",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "table_arn",
         116  +
    "TableArn",
  117    117   
    4,
  118    118   
);
  119    119   
static INVENTORYTABLECONFIGURATIONRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  120    120   
    INVENTORYTABLECONFIGURATIONRESULT_SCHEMA_ID,
  121    121   
    ::aws_smithy_schema::ShapeType::Structure,
  122    122   
    &[
  123    123   
        &INVENTORYTABLECONFIGURATIONRESULT_MEMBER_CONFIGURATION_STATE,
  124    124   
        &INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_STATUS,
  125    125   
        &INVENTORYTABLECONFIGURATIONRESULT_MEMBER_ERROR,
  126    126   
        &INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_NAME,
  127    127   
        &INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_ARN,
  128    128   
    ],
  129    129   
);
  130    130   
impl InventoryTableConfigurationResult {
  131    131   
    /// The schema for this shape.
  132    132   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVENTORYTABLECONFIGURATIONRESULT_SCHEMA;
  133    133   
}
  134    134   
impl ::aws_smithy_schema::serde::SerializableStruct for InventoryTableConfigurationResult {
  135    135   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  136    136   
    fn serialize_members(
  137    137   
        &self,
  138    138   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  139    139   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  140    140   
        {
  141    141   
            let val = &self.configuration_state;
  142    142   
            ser.write_string(&INVENTORYTABLECONFIGURATIONRESULT_MEMBER_CONFIGURATION_STATE, val.as_str())?;
  143    143   
        }
  144    144   
        if let Some(ref val) = self.table_status {
  145    145   
            ser.write_string(&INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_STATUS, val)?;
  146    146   
        }
  147    147   
        if let Some(ref val) = self.error {
  148    148   
            ser.write_struct(&INVENTORYTABLECONFIGURATIONRESULT_MEMBER_ERROR, val)?;
  149    149   
        }
  150    150   
        if let Some(ref val) = self.table_name {
  151    151   
            ser.write_string(&INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_NAME, val)?;
  152    152   
        }
  153    153   
        if let Some(ref val) = self.table_arn {
  154    154   
            ser.write_string(&INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_ARN, val)?;
  155    155   
        }
  156    156   
        Ok(())
  157    157   
    }
  158    158   
}
  159    159   
impl InventoryTableConfigurationResult {
  160    160   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  161         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  162         -
        deserializer: &mut D,
         161  +
    pub fn deserialize(
         162  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  163    163   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  164    164   
        #[allow(unused_variables, unused_mut)]
  165    165   
        let mut builder = Self::builder();
  166    166   
        #[allow(
  167    167   
            unused_variables,
  168    168   
            unreachable_code,
  169    169   
            clippy::single_match,
  170    170   
            clippy::match_single_binding,
  171    171   
            clippy::diverging_sub_expression
  172    172   
        )]
  173         -
        deserializer.read_struct(&INVENTORYTABLECONFIGURATIONRESULT_SCHEMA, (), |_, member, deser| {
         173  +
        deserializer.read_struct(&INVENTORYTABLECONFIGURATIONRESULT_SCHEMA, &mut |member, deser| {
  174    174   
            match member.member_index() {
  175    175   
                Some(0) => {
  176    176   
                    builder.configuration_state = Some(crate::types::InventoryConfigurationState::from(deser.read_string(member)?.as_str()));
  177    177   
                }
  178    178   
                Some(1) => {
  179    179   
                    builder.table_status = Some(deser.read_string(member)?);
  180    180   
                }
  181    181   
                Some(2) => {
  182    182   
                    builder.error = Some(crate::types::ErrorDetails::deserialize(deser)?);
  183    183   
                }
  184    184   
                Some(3) => {
  185    185   
                    builder.table_name = Some(deser.read_string(member)?);
  186    186   
                }
  187    187   
                Some(4) => {
  188    188   
                    builder.table_arn = Some(deser.read_string(member)?);
  189    189   
                }
  190    190   
                _ => {}
  191    191   
            }
  192    192   
            Ok(())
  193    193   
        })?;
  194    194   
        builder
  195    195   
            .build()
  196    196   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  197    197   
    }
  198    198   
}
         199  +
impl InventoryTableConfigurationResult {
         200  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         201  +
    pub fn deserialize_with_response(
         202  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         203  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         204  +
        _status: u16,
         205  +
        _body: &[u8],
         206  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         207  +
        Self::deserialize(deserializer)
         208  +
    }
         209  +
}
  199    210   
impl InventoryTableConfigurationResult {
  200    211   
    /// Creates a new builder-style object to manufacture [`InventoryTableConfigurationResult`](crate::types::InventoryTableConfigurationResult).
  201    212   
    pub fn builder() -> crate::types::builders::InventoryTableConfigurationResultBuilder {
  202    213   
        crate::types::builders::InventoryTableConfigurationResultBuilder::default()
  203    214   
    }
  204    215   
}
  205    216   
  206    217   
/// A builder for [`InventoryTableConfigurationResult`](crate::types::InventoryTableConfigurationResult).
  207    218   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  208    219   
#[non_exhaustive]