AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406

Files changed:

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_sses3.rs

@@ -1,1 +63,74 @@
   16     16   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   17     17   
    fn serialize_members(
   18     18   
        &self,
   19     19   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   20     20   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   21     21   
        Ok(())
   22     22   
    }
   23     23   
}
   24     24   
impl Sses3 {
   25     25   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   26         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   27         -
        deserializer: &mut D,
          26  +
    pub fn deserialize(
          27  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   28     28   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   29     29   
        #[allow(unused_variables, unused_mut)]
   30     30   
        let mut builder = Self::builder();
   31     31   
        #[allow(
   32     32   
            unused_variables,
   33     33   
            unreachable_code,
   34     34   
            clippy::single_match,
   35     35   
            clippy::match_single_binding,
   36     36   
            clippy::diverging_sub_expression
   37     37   
        )]
   38         -
        deserializer.read_struct(&SSES3_SCHEMA, (), |_, member, deser| {
          38  +
        deserializer.read_struct(&SSES3_SCHEMA, &mut |member, deser| {
   39     39   
            match member.member_index() {
   40     40   
                _ => {}
   41     41   
            }
   42     42   
            Ok(())
   43     43   
        })?;
   44     44   
        Ok(builder.build())
   45     45   
    }
   46     46   
}
          47  +
impl Sses3 {
          48  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          49  +
    pub fn deserialize_with_response(
          50  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          51  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          52  +
        _status: u16,
          53  +
        _body: &[u8],
          54  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          55  +
        Ok(Self::builder().build())
          56  +
    }
          57  +
}
   47     58   
impl Sses3 {
   48     59   
    /// Creates a new builder-style object to manufacture [`Sses3`](crate::types::Sses3).
   49     60   
    pub fn builder() -> crate::types::builders::Sses3Builder {
   50     61   
        crate::types::builders::Sses3Builder::default()
   51     62   
    }
   52     63   
}
   53     64   
   54     65   
/// A builder for [`Sses3`](crate::types::Sses3).
   55     66   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   56     67   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_sses3_encryption.rs

@@ -1,1 +63,74 @@
   16     16   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   17     17   
    fn serialize_members(
   18     18   
        &self,
   19     19   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   20     20   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   21     21   
        Ok(())
   22     22   
    }
   23     23   
}
   24     24   
impl Sses3Encryption {
   25     25   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   26         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   27         -
        deserializer: &mut D,
          26  +
    pub fn deserialize(
          27  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   28     28   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   29     29   
        #[allow(unused_variables, unused_mut)]
   30     30   
        let mut builder = Self::builder();
   31     31   
        #[allow(
   32     32   
            unused_variables,
   33     33   
            unreachable_code,
   34     34   
            clippy::single_match,
   35     35   
            clippy::match_single_binding,
   36     36   
            clippy::diverging_sub_expression
   37     37   
        )]
   38         -
        deserializer.read_struct(&SSES3ENCRYPTION_SCHEMA, (), |_, member, deser| {
          38  +
        deserializer.read_struct(&SSES3ENCRYPTION_SCHEMA, &mut |member, deser| {
   39     39   
            match member.member_index() {
   40     40   
                _ => {}
   41     41   
            }
   42     42   
            Ok(())
   43     43   
        })?;
   44     44   
        Ok(builder.build())
   45     45   
    }
   46     46   
}
          47  +
impl Sses3Encryption {
          48  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          49  +
    pub fn deserialize_with_response(
          50  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          51  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          52  +
        _status: u16,
          53  +
        _body: &[u8],
          54  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          55  +
        Ok(Self::builder().build())
          56  +
    }
          57  +
}
   47     58   
impl Sses3Encryption {
   48     59   
    /// Creates a new builder-style object to manufacture [`Sses3Encryption`](crate::types::Sses3Encryption).
   49     60   
    pub fn builder() -> crate::types::builders::Sses3EncryptionBuilder {
   50     61   
        crate::types::builders::Sses3EncryptionBuilder::default()
   51     62   
    }
   52     63   
}
   53     64   
   54     65   
/// A builder for [`Sses3Encryption`](crate::types::Sses3Encryption).
   55     66   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   56     67   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_sses3_filter.rs

@@ -1,1 +63,74 @@
   16     16   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   17     17   
    fn serialize_members(
   18     18   
        &self,
   19     19   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   20     20   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   21     21   
        Ok(())
   22     22   
    }
   23     23   
}
   24     24   
impl Sses3Filter {
   25     25   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   26         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   27         -
        deserializer: &mut D,
          26  +
    pub fn deserialize(
          27  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   28     28   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   29     29   
        #[allow(unused_variables, unused_mut)]
   30     30   
        let mut builder = Self::builder();
   31     31   
        #[allow(
   32     32   
            unused_variables,
   33     33   
            unreachable_code,
   34     34   
            clippy::single_match,
   35     35   
            clippy::match_single_binding,
   36     36   
            clippy::diverging_sub_expression
   37     37   
        )]
   38         -
        deserializer.read_struct(&SSES3FILTER_SCHEMA, (), |_, member, deser| {
          38  +
        deserializer.read_struct(&SSES3FILTER_SCHEMA, &mut |member, deser| {
   39     39   
            match member.member_index() {
   40     40   
                _ => {}
   41     41   
            }
   42     42   
            Ok(())
   43     43   
        })?;
   44     44   
        Ok(builder.build())
   45     45   
    }
   46     46   
}
          47  +
impl Sses3Filter {
          48  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          49  +
    pub fn deserialize_with_response(
          50  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          51  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          52  +
        _status: u16,
          53  +
        _body: &[u8],
          54  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          55  +
        Ok(Self::builder().build())
          56  +
    }
          57  +
}
   47     58   
impl Sses3Filter {
   48     59   
    /// Creates a new builder-style object to manufacture [`Sses3Filter`](crate::types::Sses3Filter).
   49     60   
    pub fn builder() -> crate::types::builders::Sses3FilterBuilder {
   50     61   
        crate::types::builders::Sses3FilterBuilder::default()
   51     62   
    }
   52     63   
}
   53     64   
   54     65   
/// A builder for [`Sses3Filter`](crate::types::Sses3Filter).
   55     66   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   56     67   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_storage_lens_aws_org.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_storage_lens_configuration.rs

@@ -41,41 +275,288 @@
   61     61   
    "com.amazonaws.s3control",
   62     62   
    "StorageLensConfiguration",
   63     63   
);
   64     64   
static STORAGELENSCONFIGURATION_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static(
   66     66   
        "com.amazonaws.s3control#StorageLensConfiguration$Id",
   67     67   
        "com.amazonaws.s3control",
   68     68   
        "StorageLensConfiguration",
   69     69   
    ),
   70     70   
    ::aws_smithy_schema::ShapeType::String,
   71         -
    "id",
          71  +
    "Id",
   72     72   
    0,
   73     73   
);
   74     74   
static STORAGELENSCONFIGURATION_MEMBER_ACCOUNT_LEVEL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "com.amazonaws.s3control#StorageLensConfiguration$AccountLevel",
   77     77   
        "com.amazonaws.s3control",
   78     78   
        "StorageLensConfiguration",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::Structure,
   81         -
    "account_level",
          81  +
    "AccountLevel",
   82     82   
    1,
   83     83   
);
   84     84   
static STORAGELENSCONFIGURATION_MEMBER_INCLUDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "com.amazonaws.s3control#StorageLensConfiguration$Include",
   87     87   
        "com.amazonaws.s3control",
   88     88   
        "StorageLensConfiguration",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::Structure,
   91         -
    "include",
          91  +
    "Include",
   92     92   
    2,
   93     93   
);
   94     94   
static STORAGELENSCONFIGURATION_MEMBER_EXCLUDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static(
   96     96   
        "com.amazonaws.s3control#StorageLensConfiguration$Exclude",
   97     97   
        "com.amazonaws.s3control",
   98     98   
        "StorageLensConfiguration",
   99     99   
    ),
  100    100   
    ::aws_smithy_schema::ShapeType::Structure,
  101         -
    "exclude",
         101  +
    "Exclude",
  102    102   
    3,
  103    103   
);
  104    104   
static STORAGELENSCONFIGURATION_MEMBER_DATA_EXPORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static(
  106    106   
        "com.amazonaws.s3control#StorageLensConfiguration$DataExport",
  107    107   
        "com.amazonaws.s3control",
  108    108   
        "StorageLensConfiguration",
  109    109   
    ),
  110    110   
    ::aws_smithy_schema::ShapeType::Structure,
  111         -
    "data_export",
         111  +
    "DataExport",
  112    112   
    4,
  113    113   
);
  114    114   
static STORAGELENSCONFIGURATION_MEMBER_IS_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "com.amazonaws.s3control#StorageLensConfiguration$IsEnabled",
  117    117   
        "com.amazonaws.s3control",
  118    118   
        "StorageLensConfiguration",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::Boolean,
  121         -
    "is_enabled",
         121  +
    "IsEnabled",
  122    122   
    5,
  123    123   
);
  124    124   
static STORAGELENSCONFIGURATION_MEMBER_AWS_ORG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static(
  126    126   
        "com.amazonaws.s3control#StorageLensConfiguration$AwsOrg",
  127    127   
        "com.amazonaws.s3control",
  128    128   
        "StorageLensConfiguration",
  129    129   
    ),
  130    130   
    ::aws_smithy_schema::ShapeType::Structure,
  131         -
    "aws_org",
         131  +
    "AwsOrg",
  132    132   
    6,
  133    133   
);
  134    134   
static STORAGELENSCONFIGURATION_MEMBER_STORAGE_LENS_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "com.amazonaws.s3control#StorageLensConfiguration$StorageLensArn",
  137    137   
        "com.amazonaws.s3control",
  138    138   
        "StorageLensConfiguration",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::String,
  141         -
    "storage_lens_arn",
         141  +
    "StorageLensArn",
  142    142   
    7,
  143    143   
);
  144    144   
static STORAGELENSCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  145    145   
    STORAGELENSCONFIGURATION_SCHEMA_ID,
  146    146   
    ::aws_smithy_schema::ShapeType::Structure,
  147    147   
    &[
  148    148   
        &STORAGELENSCONFIGURATION_MEMBER_ID,
  149    149   
        &STORAGELENSCONFIGURATION_MEMBER_ACCOUNT_LEVEL,
  150    150   
        &STORAGELENSCONFIGURATION_MEMBER_INCLUDE,
  151    151   
        &STORAGELENSCONFIGURATION_MEMBER_EXCLUDE,
  152    152   
        &STORAGELENSCONFIGURATION_MEMBER_DATA_EXPORT,
  153    153   
        &STORAGELENSCONFIGURATION_MEMBER_IS_ENABLED,
  154    154   
        &STORAGELENSCONFIGURATION_MEMBER_AWS_ORG,
  155    155   
        &STORAGELENSCONFIGURATION_MEMBER_STORAGE_LENS_ARN,
  156    156   
    ],
  157    157   
);
  158    158   
impl StorageLensConfiguration {
  159    159   
    /// The schema for this shape.
  160    160   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STORAGELENSCONFIGURATION_SCHEMA;
  161    161   
}
  162    162   
impl ::aws_smithy_schema::serde::SerializableStruct for StorageLensConfiguration {
  163    163   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  164    164   
    fn serialize_members(
  165    165   
        &self,
  166    166   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  167    167   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  168    168   
        {
  169    169   
            let val = &self.id;
  170    170   
            ser.write_string(&STORAGELENSCONFIGURATION_MEMBER_ID, val)?;
  171    171   
        }
  172    172   
        if let Some(ref val) = self.account_level {
  173    173   
            ser.write_struct(&STORAGELENSCONFIGURATION_MEMBER_ACCOUNT_LEVEL, val)?;
  174    174   
        }
  175    175   
        if let Some(ref val) = self.include {
  176    176   
            ser.write_struct(&STORAGELENSCONFIGURATION_MEMBER_INCLUDE, val)?;
  177    177   
        }
  178    178   
        if let Some(ref val) = self.exclude {
  179    179   
            ser.write_struct(&STORAGELENSCONFIGURATION_MEMBER_EXCLUDE, val)?;
  180    180   
        }
  181    181   
        if let Some(ref val) = self.data_export {
  182    182   
            ser.write_struct(&STORAGELENSCONFIGURATION_MEMBER_DATA_EXPORT, val)?;
  183    183   
        }
  184    184   
        {
  185    185   
            let val = &self.is_enabled;
  186    186   
            ser.write_boolean(&STORAGELENSCONFIGURATION_MEMBER_IS_ENABLED, *val)?;
  187    187   
        }
  188    188   
        if let Some(ref val) = self.aws_org {
  189    189   
            ser.write_struct(&STORAGELENSCONFIGURATION_MEMBER_AWS_ORG, val)?;
  190    190   
        }
  191    191   
        if let Some(ref val) = self.storage_lens_arn {
  192    192   
            ser.write_string(&STORAGELENSCONFIGURATION_MEMBER_STORAGE_LENS_ARN, val)?;
  193    193   
        }
  194    194   
        Ok(())
  195    195   
    }
  196    196   
}
  197    197   
impl StorageLensConfiguration {
  198    198   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  199         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  200         -
        deserializer: &mut D,
         199  +
    pub fn deserialize(
         200  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  201    201   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  202    202   
        #[allow(unused_variables, unused_mut)]
  203    203   
        let mut builder = Self::builder();
  204    204   
        #[allow(
  205    205   
            unused_variables,
  206    206   
            unreachable_code,
  207    207   
            clippy::single_match,
  208    208   
            clippy::match_single_binding,
  209    209   
            clippy::diverging_sub_expression
  210    210   
        )]
  211         -
        deserializer.read_struct(&STORAGELENSCONFIGURATION_SCHEMA, (), |_, member, deser| {
         211  +
        deserializer.read_struct(&STORAGELENSCONFIGURATION_SCHEMA, &mut |member, deser| {
  212    212   
            match member.member_index() {
  213    213   
                Some(0) => {
  214    214   
                    builder.id = Some(deser.read_string(member)?);
  215    215   
                }
  216    216   
                Some(1) => {
  217    217   
                    builder.account_level = Some(crate::types::AccountLevel::deserialize(deser)?);
  218    218   
                }
  219    219   
                Some(2) => {
  220    220   
                    builder.include = Some(crate::types::Include::deserialize(deser)?);
  221    221   
                }
  222    222   
                Some(3) => {
  223    223   
                    builder.exclude = Some(crate::types::Exclude::deserialize(deser)?);
  224    224   
                }
  225    225   
                Some(4) => {
  226    226   
                    builder.data_export = Some(crate::types::StorageLensDataExport::deserialize(deser)?);
  227    227   
                }
  228    228   
                Some(5) => {
  229    229   
                    builder.is_enabled = Some(deser.read_boolean(member)?);
  230    230   
                }
  231    231   
                Some(6) => {
  232    232   
                    builder.aws_org = Some(crate::types::StorageLensAwsOrg::deserialize(deser)?);
  233    233   
                }
  234    234   
                Some(7) => {
  235    235   
                    builder.storage_lens_arn = Some(deser.read_string(member)?);
  236    236   
                }
  237    237   
                _ => {}
  238    238   
            }
  239    239   
            Ok(())
  240    240   
        })?;
         241  +
        builder.id = builder.id.or(Some(String::new()));
         242  +
        builder.is_enabled = builder.is_enabled.or(Some(false));
  241    243   
        builder
  242    244   
            .build()
  243    245   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  244    246   
    }
  245    247   
}
         248  +
impl StorageLensConfiguration {
         249  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         250  +
    pub fn deserialize_with_response(
         251  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         252  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         253  +
        _status: u16,
         254  +
        _body: &[u8],
         255  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         256  +
        Self::deserialize(deserializer)
         257  +
    }
         258  +
}
  246    259   
impl StorageLensConfiguration {
  247    260   
    /// Creates a new builder-style object to manufacture [`StorageLensConfiguration`](crate::types::StorageLensConfiguration).
  248    261   
    pub fn builder() -> crate::types::builders::StorageLensConfigurationBuilder {
  249    262   
        crate::types::builders::StorageLensConfigurationBuilder::default()
  250    263   
    }
  251    264   
}
  252    265   
  253    266   
/// A builder for [`StorageLensConfiguration`](crate::types::StorageLensConfiguration).
  254    267   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  255    268   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_storage_lens_data_export.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_storage_lens_data_export_encryption.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_storage_lens_group.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_storage_lens_group_and_operator.rs

@@ -28,28 +128,128 @@
   48     48   
    "com.amazonaws.s3control",
   49     49   
    "StorageLensGroupAndOperator",
   50     50   
);
   51     51   
static STORAGELENSGROUPANDOPERATOR_MEMBER_MATCH_ANY_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.s3control#StorageLensGroupAndOperator$MatchAnyPrefix",
   54     54   
        "com.amazonaws.s3control",
   55     55   
        "StorageLensGroupAndOperator",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::List,
   58         -
    "match_any_prefix",
          58  +
    "MatchAnyPrefix",
   59     59   
    0,
   60     60   
);
   61     61   
static STORAGELENSGROUPANDOPERATOR_MEMBER_MATCH_ANY_SUFFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.s3control#StorageLensGroupAndOperator$MatchAnySuffix",
   64     64   
        "com.amazonaws.s3control",
   65     65   
        "StorageLensGroupAndOperator",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::List,
   68         -
    "match_any_suffix",
          68  +
    "MatchAnySuffix",
   69     69   
    1,
   70     70   
);
   71     71   
static STORAGELENSGROUPANDOPERATOR_MEMBER_MATCH_ANY_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.s3control#StorageLensGroupAndOperator$MatchAnyTag",
   74     74   
        "com.amazonaws.s3control",
   75     75   
        "StorageLensGroupAndOperator",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::List,
   78         -
    "match_any_tag",
          78  +
    "MatchAnyTag",
   79     79   
    2,
   80     80   
);
   81     81   
static STORAGELENSGROUPANDOPERATOR_MEMBER_MATCH_OBJECT_AGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.s3control#StorageLensGroupAndOperator$MatchObjectAge",
   84     84   
        "com.amazonaws.s3control",
   85     85   
        "StorageLensGroupAndOperator",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::Structure,
   88         -
    "match_object_age",
          88  +
    "MatchObjectAge",
   89     89   
    3,
   90     90   
);
   91     91   
static STORAGELENSGROUPANDOPERATOR_MEMBER_MATCH_OBJECT_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.s3control#StorageLensGroupAndOperator$MatchObjectSize",
   94     94   
        "com.amazonaws.s3control",
   95     95   
        "StorageLensGroupAndOperator",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::Structure,
   98         -
    "match_object_size",
          98  +
    "MatchObjectSize",
   99     99   
    4,
  100    100   
);
  101    101   
static STORAGELENSGROUPANDOPERATOR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  102    102   
    STORAGELENSGROUPANDOPERATOR_SCHEMA_ID,
  103    103   
    ::aws_smithy_schema::ShapeType::Structure,
  104    104   
    &[
  105    105   
        &STORAGELENSGROUPANDOPERATOR_MEMBER_MATCH_ANY_PREFIX,
  106    106   
        &STORAGELENSGROUPANDOPERATOR_MEMBER_MATCH_ANY_SUFFIX,
  107    107   
        &STORAGELENSGROUPANDOPERATOR_MEMBER_MATCH_ANY_TAG,
  108    108   
        &STORAGELENSGROUPANDOPERATOR_MEMBER_MATCH_OBJECT_AGE,
@@ -136,136 +261,249 @@
  156    156   
            ser.write_struct(&STORAGELENSGROUPANDOPERATOR_MEMBER_MATCH_OBJECT_AGE, val)?;
  157    157   
        }
  158    158   
        if let Some(ref val) = self.match_object_size {
  159    159   
            ser.write_struct(&STORAGELENSGROUPANDOPERATOR_MEMBER_MATCH_OBJECT_SIZE, val)?;
  160    160   
        }
  161    161   
        Ok(())
  162    162   
    }
  163    163   
}
  164    164   
impl StorageLensGroupAndOperator {
  165    165   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  166         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  167         -
        deserializer: &mut D,
         166  +
    pub fn deserialize(
         167  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  168    168   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  169    169   
        #[allow(unused_variables, unused_mut)]
  170    170   
        let mut builder = Self::builder();
  171    171   
        #[allow(
  172    172   
            unused_variables,
  173    173   
            unreachable_code,
  174    174   
            clippy::single_match,
  175    175   
            clippy::match_single_binding,
  176    176   
            clippy::diverging_sub_expression
  177    177   
        )]
  178         -
        deserializer.read_struct(&STORAGELENSGROUPANDOPERATOR_SCHEMA, (), |_, member, deser| {
         178  +
        deserializer.read_struct(&STORAGELENSGROUPANDOPERATOR_SCHEMA, &mut |member, deser| {
  179    179   
            match member.member_index() {
  180    180   
                Some(0) => {
  181         -
                    builder.match_any_prefix = Some({
  182         -
                        let container = if let Some(cap) = deser.container_size() {
  183         -
                            Vec::with_capacity(cap)
  184         -
                        } else {
  185         -
                            Vec::new()
  186         -
                        };
  187         -
                        deser.read_list(member, container, |mut list, deser| {
  188         -
                            list.push(deser.read_string(member)?);
  189         -
                            Ok(list)
  190         -
                        })?
  191         -
                    });
         181  +
                    builder.match_any_prefix = Some(deser.read_string_list(member)?);
  192    182   
                }
  193    183   
                Some(1) => {
  194         -
                    builder.match_any_suffix = Some({
  195         -
                        let container = if let Some(cap) = deser.container_size() {
  196         -
                            Vec::with_capacity(cap)
  197         -
                        } else {
  198         -
                            Vec::new()
  199         -
                        };
  200         -
                        deser.read_list(member, container, |mut list, deser| {
  201         -
                            list.push(deser.read_string(member)?);
  202         -
                            Ok(list)
  203         -
                        })?
  204         -
                    });
         184  +
                    builder.match_any_suffix = Some(deser.read_string_list(member)?);
  205    185   
                }
  206    186   
                Some(2) => {
  207    187   
                    builder.match_any_tag = Some({
  208         -
                        let container = if let Some(cap) = deser.container_size() {
  209         -
                            Vec::with_capacity(cap)
  210         -
                        } else {
  211         -
                            Vec::new()
  212         -
                        };
  213         -
                        deser.read_list(member, container, |mut list, deser| {
  214         -
                            list.push(crate::types::S3Tag::deserialize(deser)?);
  215         -
                            Ok(list)
  216         -
                        })?
         188  +
                        let mut container = Vec::new();
         189  +
                        deser.read_list(member, &mut |deser| {
         190  +
                            container.push(crate::types::S3Tag::deserialize(deser)?);
         191  +
                            Ok(())
         192  +
                        })?;
         193  +
                        container
  217    194   
                    });
  218    195   
                }
  219    196   
                Some(3) => {
  220    197   
                    builder.match_object_age = Some(crate::types::MatchObjectAge::deserialize(deser)?);
  221    198   
                }
  222    199   
                Some(4) => {
  223    200   
                    builder.match_object_size = Some(crate::types::MatchObjectSize::deserialize(deser)?);
  224    201   
                }
  225    202   
                _ => {}
  226    203   
            }
  227    204   
            Ok(())
  228    205   
        })?;
  229    206   
        Ok(builder.build())
  230    207   
    }
  231    208   
}
         209  +
impl StorageLensGroupAndOperator {
         210  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         211  +
    pub fn deserialize_with_response(
         212  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         213  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         214  +
        _status: u16,
         215  +
        _body: &[u8],
         216  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         217  +
        Self::deserialize(deserializer)
         218  +
    }
         219  +
}
  232    220   
impl StorageLensGroupAndOperator {
  233    221   
    /// Creates a new builder-style object to manufacture [`StorageLensGroupAndOperator`](crate::types::StorageLensGroupAndOperator).
  234    222   
    pub fn builder() -> crate::types::builders::StorageLensGroupAndOperatorBuilder {
  235    223   
        crate::types::builders::StorageLensGroupAndOperatorBuilder::default()
  236    224   
    }
  237    225   
}
  238    226   
  239    227   
/// A builder for [`StorageLensGroupAndOperator`](crate::types::StorageLensGroupAndOperator).
  240    228   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  241    229   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_storage_lens_group_filter.rs

@@ -40,40 +160,160 @@
   60     60   
    "com.amazonaws.s3control",
   61     61   
    "StorageLensGroupFilter",
   62     62   
);
   63     63   
static STORAGELENSGROUPFILTER_MEMBER_MATCH_ANY_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.s3control#StorageLensGroupFilter$MatchAnyPrefix",
   66     66   
        "com.amazonaws.s3control",
   67     67   
        "StorageLensGroupFilter",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::List,
   70         -
    "match_any_prefix",
          70  +
    "MatchAnyPrefix",
   71     71   
    0,
   72     72   
);
   73     73   
static STORAGELENSGROUPFILTER_MEMBER_MATCH_ANY_SUFFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.s3control#StorageLensGroupFilter$MatchAnySuffix",
   76     76   
        "com.amazonaws.s3control",
   77     77   
        "StorageLensGroupFilter",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::List,
   80         -
    "match_any_suffix",
          80  +
    "MatchAnySuffix",
   81     81   
    1,
   82     82   
);
   83     83   
static STORAGELENSGROUPFILTER_MEMBER_MATCH_ANY_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.s3control#StorageLensGroupFilter$MatchAnyTag",
   86     86   
        "com.amazonaws.s3control",
   87     87   
        "StorageLensGroupFilter",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::List,
   90         -
    "match_any_tag",
          90  +
    "MatchAnyTag",
   91     91   
    2,
   92     92   
);
   93     93   
static STORAGELENSGROUPFILTER_MEMBER_MATCH_OBJECT_AGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.s3control#StorageLensGroupFilter$MatchObjectAge",
   96     96   
        "com.amazonaws.s3control",
   97     97   
        "StorageLensGroupFilter",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::Structure,
  100         -
    "match_object_age",
         100  +
    "MatchObjectAge",
  101    101   
    3,
  102    102   
);
  103    103   
static STORAGELENSGROUPFILTER_MEMBER_MATCH_OBJECT_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.s3control#StorageLensGroupFilter$MatchObjectSize",
  106    106   
        "com.amazonaws.s3control",
  107    107   
        "StorageLensGroupFilter",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::Structure,
  110         -
    "match_object_size",
         110  +
    "MatchObjectSize",
  111    111   
    4,
  112    112   
);
  113    113   
static STORAGELENSGROUPFILTER_MEMBER_AND: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static(
  115    115   
        "com.amazonaws.s3control#StorageLensGroupFilter$And",
  116    116   
        "com.amazonaws.s3control",
  117    117   
        "StorageLensGroupFilter",
  118    118   
    ),
  119    119   
    ::aws_smithy_schema::ShapeType::Structure,
  120         -
    "and",
         120  +
    "And",
  121    121   
    5,
  122    122   
);
  123    123   
static STORAGELENSGROUPFILTER_MEMBER_OR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.s3control#StorageLensGroupFilter$Or",
  126    126   
        "com.amazonaws.s3control",
  127    127   
        "StorageLensGroupFilter",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::Structure,
  130         -
    "or",
         130  +
    "Or",
  131    131   
    6,
  132    132   
);
  133    133   
static STORAGELENSGROUPFILTER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  134    134   
    STORAGELENSGROUPFILTER_SCHEMA_ID,
  135    135   
    ::aws_smithy_schema::ShapeType::Structure,
  136    136   
    &[
  137    137   
        &STORAGELENSGROUPFILTER_MEMBER_MATCH_ANY_PREFIX,
  138    138   
        &STORAGELENSGROUPFILTER_MEMBER_MATCH_ANY_SUFFIX,
  139    139   
        &STORAGELENSGROUPFILTER_MEMBER_MATCH_ANY_TAG,
  140    140   
        &STORAGELENSGROUPFILTER_MEMBER_MATCH_OBJECT_AGE,
@@ -176,176 +307,295 @@
  196    196   
            ser.write_struct(&STORAGELENSGROUPFILTER_MEMBER_AND, val)?;
  197    197   
        }
  198    198   
        if let Some(ref val) = self.or {
  199    199   
            ser.write_struct(&STORAGELENSGROUPFILTER_MEMBER_OR, val)?;
  200    200   
        }
  201    201   
        Ok(())
  202    202   
    }
  203    203   
}
  204    204   
impl StorageLensGroupFilter {
  205    205   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  206         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  207         -
        deserializer: &mut D,
         206  +
    pub fn deserialize(
         207  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  208    208   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  209    209   
        #[allow(unused_variables, unused_mut)]
  210    210   
        let mut builder = Self::builder();
  211    211   
        #[allow(
  212    212   
            unused_variables,
  213    213   
            unreachable_code,
  214    214   
            clippy::single_match,
  215    215   
            clippy::match_single_binding,
  216    216   
            clippy::diverging_sub_expression
  217    217   
        )]
  218         -
        deserializer.read_struct(&STORAGELENSGROUPFILTER_SCHEMA, (), |_, member, deser| {
         218  +
        deserializer.read_struct(&STORAGELENSGROUPFILTER_SCHEMA, &mut |member, deser| {
  219    219   
            match member.member_index() {
  220    220   
                Some(0) => {
  221         -
                    builder.match_any_prefix = Some({
  222         -
                        let container = if let Some(cap) = deser.container_size() {
  223         -
                            Vec::with_capacity(cap)
  224         -
                        } else {
  225         -
                            Vec::new()
  226         -
                        };
  227         -
                        deser.read_list(member, container, |mut list, deser| {
  228         -
                            list.push(deser.read_string(member)?);
  229         -
                            Ok(list)
  230         -
                        })?
  231         -
                    });
         221  +
                    builder.match_any_prefix = Some(deser.read_string_list(member)?);
  232    222   
                }
  233    223   
                Some(1) => {
  234         -
                    builder.match_any_suffix = Some({
  235         -
                        let container = if let Some(cap) = deser.container_size() {
  236         -
                            Vec::with_capacity(cap)
  237         -
                        } else {
  238         -
                            Vec::new()
  239         -
                        };
  240         -
                        deser.read_list(member, container, |mut list, deser| {
  241         -
                            list.push(deser.read_string(member)?);
  242         -
                            Ok(list)
  243         -
                        })?
  244         -
                    });
         224  +
                    builder.match_any_suffix = Some(deser.read_string_list(member)?);
  245    225   
                }
  246    226   
                Some(2) => {
  247    227   
                    builder.match_any_tag = Some({
  248         -
                        let container = if let Some(cap) = deser.container_size() {
  249         -
                            Vec::with_capacity(cap)
  250         -
                        } else {
  251         -
                            Vec::new()
  252         -
                        };
  253         -
                        deser.read_list(member, container, |mut list, deser| {
  254         -
                            list.push(crate::types::S3Tag::deserialize(deser)?);
  255         -
                            Ok(list)
  256         -
                        })?
         228  +
                        let mut container = Vec::new();
         229  +
                        deser.read_list(member, &mut |deser| {
         230  +
                            container.push(crate::types::S3Tag::deserialize(deser)?);
         231  +
                            Ok(())
         232  +
                        })?;
         233  +
                        container
  257    234   
                    });
  258    235   
                }
  259    236   
                Some(3) => {
  260    237   
                    builder.match_object_age = Some(crate::types::MatchObjectAge::deserialize(deser)?);
  261    238   
                }
  262    239   
                Some(4) => {
  263    240   
                    builder.match_object_size = Some(crate::types::MatchObjectSize::deserialize(deser)?);
  264    241   
                }
  265    242   
                Some(5) => {
  266    243   
                    builder.and = Some(crate::types::StorageLensGroupAndOperator::deserialize(deser)?);
  267    244   
                }
  268    245   
                Some(6) => {
  269    246   
                    builder.or = Some(crate::types::StorageLensGroupOrOperator::deserialize(deser)?);
  270    247   
                }
  271    248   
                _ => {}
  272    249   
            }
  273    250   
            Ok(())
  274    251   
        })?;
  275    252   
        Ok(builder.build())
  276    253   
    }
  277    254   
}
         255  +
impl StorageLensGroupFilter {
         256  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         257  +
    pub fn deserialize_with_response(
         258  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         259  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         260  +
        _status: u16,
         261  +
        _body: &[u8],
         262  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         263  +
        Self::deserialize(deserializer)
         264  +
    }
         265  +
}
  278    266   
impl StorageLensGroupFilter {
  279    267   
    /// Creates a new builder-style object to manufacture [`StorageLensGroupFilter`](crate::types::StorageLensGroupFilter).
  280    268   
    pub fn builder() -> crate::types::builders::StorageLensGroupFilterBuilder {
  281    269   
        crate::types::builders::StorageLensGroupFilterBuilder::default()
  282    270   
    }
  283    271   
}
  284    272   
  285    273   
/// A builder for [`StorageLensGroupFilter`](crate::types::StorageLensGroupFilter).
  286    274   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  287    275   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_storage_lens_group_level.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_storage_lens_group_level_selection_criteria.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_storage_lens_group_or_operator.rs

@@ -28,28 +128,128 @@
   48     48   
    "com.amazonaws.s3control",
   49     49   
    "StorageLensGroupOrOperator",
   50     50   
);
   51     51   
static STORAGELENSGROUPOROPERATOR_MEMBER_MATCH_ANY_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.s3control#StorageLensGroupOrOperator$MatchAnyPrefix",
   54     54   
        "com.amazonaws.s3control",
   55     55   
        "StorageLensGroupOrOperator",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::List,
   58         -
    "match_any_prefix",
          58  +
    "MatchAnyPrefix",
   59     59   
    0,
   60     60   
);
   61     61   
static STORAGELENSGROUPOROPERATOR_MEMBER_MATCH_ANY_SUFFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.s3control#StorageLensGroupOrOperator$MatchAnySuffix",
   64     64   
        "com.amazonaws.s3control",
   65     65   
        "StorageLensGroupOrOperator",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::List,
   68         -
    "match_any_suffix",
          68  +
    "MatchAnySuffix",
   69     69   
    1,
   70     70   
);
   71     71   
static STORAGELENSGROUPOROPERATOR_MEMBER_MATCH_ANY_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.s3control#StorageLensGroupOrOperator$MatchAnyTag",
   74     74   
        "com.amazonaws.s3control",
   75     75   
        "StorageLensGroupOrOperator",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::List,
   78         -
    "match_any_tag",
          78  +
    "MatchAnyTag",
   79     79   
    2,
   80     80   
);
   81     81   
static STORAGELENSGROUPOROPERATOR_MEMBER_MATCH_OBJECT_AGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.s3control#StorageLensGroupOrOperator$MatchObjectAge",
   84     84   
        "com.amazonaws.s3control",
   85     85   
        "StorageLensGroupOrOperator",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::Structure,
   88         -
    "match_object_age",
          88  +
    "MatchObjectAge",
   89     89   
    3,
   90     90   
);
   91     91   
static STORAGELENSGROUPOROPERATOR_MEMBER_MATCH_OBJECT_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.s3control#StorageLensGroupOrOperator$MatchObjectSize",
   94     94   
        "com.amazonaws.s3control",
   95     95   
        "StorageLensGroupOrOperator",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::Structure,
   98         -
    "match_object_size",
          98  +
    "MatchObjectSize",
   99     99   
    4,
  100    100   
);
  101    101   
static STORAGELENSGROUPOROPERATOR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  102    102   
    STORAGELENSGROUPOROPERATOR_SCHEMA_ID,
  103    103   
    ::aws_smithy_schema::ShapeType::Structure,
  104    104   
    &[
  105    105   
        &STORAGELENSGROUPOROPERATOR_MEMBER_MATCH_ANY_PREFIX,
  106    106   
        &STORAGELENSGROUPOROPERATOR_MEMBER_MATCH_ANY_SUFFIX,
  107    107   
        &STORAGELENSGROUPOROPERATOR_MEMBER_MATCH_ANY_TAG,
  108    108   
        &STORAGELENSGROUPOROPERATOR_MEMBER_MATCH_OBJECT_AGE,
@@ -136,136 +261,249 @@
  156    156   
            ser.write_struct(&STORAGELENSGROUPOROPERATOR_MEMBER_MATCH_OBJECT_AGE, val)?;
  157    157   
        }
  158    158   
        if let Some(ref val) = self.match_object_size {
  159    159   
            ser.write_struct(&STORAGELENSGROUPOROPERATOR_MEMBER_MATCH_OBJECT_SIZE, val)?;
  160    160   
        }
  161    161   
        Ok(())
  162    162   
    }
  163    163   
}
  164    164   
impl StorageLensGroupOrOperator {
  165    165   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  166         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  167         -
        deserializer: &mut D,
         166  +
    pub fn deserialize(
         167  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  168    168   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  169    169   
        #[allow(unused_variables, unused_mut)]
  170    170   
        let mut builder = Self::builder();
  171    171   
        #[allow(
  172    172   
            unused_variables,
  173    173   
            unreachable_code,
  174    174   
            clippy::single_match,
  175    175   
            clippy::match_single_binding,
  176    176   
            clippy::diverging_sub_expression
  177    177   
        )]
  178         -
        deserializer.read_struct(&STORAGELENSGROUPOROPERATOR_SCHEMA, (), |_, member, deser| {
         178  +
        deserializer.read_struct(&STORAGELENSGROUPOROPERATOR_SCHEMA, &mut |member, deser| {
  179    179   
            match member.member_index() {
  180    180   
                Some(0) => {
  181         -
                    builder.match_any_prefix = Some({
  182         -
                        let container = if let Some(cap) = deser.container_size() {
  183         -
                            Vec::with_capacity(cap)
  184         -
                        } else {
  185         -
                            Vec::new()
  186         -
                        };
  187         -
                        deser.read_list(member, container, |mut list, deser| {
  188         -
                            list.push(deser.read_string(member)?);
  189         -
                            Ok(list)
  190         -
                        })?
  191         -
                    });
         181  +
                    builder.match_any_prefix = Some(deser.read_string_list(member)?);
  192    182   
                }
  193    183   
                Some(1) => {
  194         -
                    builder.match_any_suffix = Some({
  195         -
                        let container = if let Some(cap) = deser.container_size() {
  196         -
                            Vec::with_capacity(cap)
  197         -
                        } else {
  198         -
                            Vec::new()
  199         -
                        };
  200         -
                        deser.read_list(member, container, |mut list, deser| {
  201         -
                            list.push(deser.read_string(member)?);
  202         -
                            Ok(list)
  203         -
                        })?
  204         -
                    });
         184  +
                    builder.match_any_suffix = Some(deser.read_string_list(member)?);
  205    185   
                }
  206    186   
                Some(2) => {
  207    187   
                    builder.match_any_tag = Some({
  208         -
                        let container = if let Some(cap) = deser.container_size() {
  209         -
                            Vec::with_capacity(cap)
  210         -
                        } else {
  211         -
                            Vec::new()
  212         -
                        };
  213         -
                        deser.read_list(member, container, |mut list, deser| {
  214         -
                            list.push(crate::types::S3Tag::deserialize(deser)?);
  215         -
                            Ok(list)
  216         -
                        })?
         188  +
                        let mut container = Vec::new();
         189  +
                        deser.read_list(member, &mut |deser| {
         190  +
                            container.push(crate::types::S3Tag::deserialize(deser)?);
         191  +
                            Ok(())
         192  +
                        })?;
         193  +
                        container
  217    194   
                    });
  218    195   
                }
  219    196   
                Some(3) => {
  220    197   
                    builder.match_object_age = Some(crate::types::MatchObjectAge::deserialize(deser)?);
  221    198   
                }
  222    199   
                Some(4) => {
  223    200   
                    builder.match_object_size = Some(crate::types::MatchObjectSize::deserialize(deser)?);
  224    201   
                }
  225    202   
                _ => {}
  226    203   
            }
  227    204   
            Ok(())
  228    205   
        })?;
  229    206   
        Ok(builder.build())
  230    207   
    }
  231    208   
}
         209  +
impl StorageLensGroupOrOperator {
         210  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         211  +
    pub fn deserialize_with_response(
         212  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         213  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         214  +
        _status: u16,
         215  +
        _body: &[u8],
         216  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         217  +
        Self::deserialize(deserializer)
         218  +
    }
         219  +
}
  232    220   
impl StorageLensGroupOrOperator {
  233    221   
    /// Creates a new builder-style object to manufacture [`StorageLensGroupOrOperator`](crate::types::StorageLensGroupOrOperator).
  234    222   
    pub fn builder() -> crate::types::builders::StorageLensGroupOrOperatorBuilder {
  235    223   
        crate::types::builders::StorageLensGroupOrOperatorBuilder::default()
  236    224   
    }
  237    225   
}
  238    226   
  239    227   
/// A builder for [`StorageLensGroupOrOperator`](crate::types::StorageLensGroupOrOperator).
  240    228   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  241    229   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_storage_lens_tag.rs

@@ -1,1 +128,141 @@
   19     19   
    pub fn value(&self) -> &str {
   20     20   
        use std::ops::Deref;
   21     21   
        self.value.deref()
   22     22   
    }
   23     23   
}
   24     24   
static STORAGELENSTAG_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3control#StorageLensTag", "com.amazonaws.s3control", "StorageLensTag");
   26     26   
static STORAGELENSTAG_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3control#StorageLensTag$Key", "com.amazonaws.s3control", "StorageLensTag"),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "key",
          29  +
    "Key",
   30     30   
    0,
   31     31   
);
   32     32   
static STORAGELENSTAG_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static(
   34     34   
        "com.amazonaws.s3control#StorageLensTag$Value",
   35     35   
        "com.amazonaws.s3control",
   36     36   
        "StorageLensTag",
   37     37   
    ),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "value",
          39  +
    "Value",
   40     40   
    1,
   41     41   
);
   42     42   
static STORAGELENSTAG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   43     43   
    STORAGELENSTAG_SCHEMA_ID,
   44     44   
    ::aws_smithy_schema::ShapeType::Structure,
   45     45   
    &[&STORAGELENSTAG_MEMBER_KEY, &STORAGELENSTAG_MEMBER_VALUE],
   46     46   
);
   47     47   
impl StorageLensTag {
   48     48   
    /// The schema for this shape.
   49     49   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STORAGELENSTAG_SCHEMA;
   50     50   
}
   51     51   
impl ::aws_smithy_schema::serde::SerializableStruct for StorageLensTag {
   52     52   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   53     53   
    fn serialize_members(
   54     54   
        &self,
   55     55   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   56     56   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   57     57   
        {
   58     58   
            let val = &self.key;
   59     59   
            ser.write_string(&STORAGELENSTAG_MEMBER_KEY, val)?;
   60     60   
        }
   61     61   
        {
   62     62   
            let val = &self.value;
   63     63   
            ser.write_string(&STORAGELENSTAG_MEMBER_VALUE, val)?;
   64     64   
        }
   65     65   
        Ok(())
   66     66   
    }
   67     67   
}
   68     68   
impl StorageLensTag {
   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(&STORAGELENSTAG_SCHEMA, (), |_, member, deser| {
          82  +
        deserializer.read_struct(&STORAGELENSTAG_SCHEMA, &mut |member, deser| {
   83     83   
            match member.member_index() {
   84     84   
                Some(0) => {
   85     85   
                    builder.key = Some(deser.read_string(member)?);
   86     86   
                }
   87     87   
                Some(1) => {
   88     88   
                    builder.value = Some(deser.read_string(member)?);
   89     89   
                }
   90     90   
                _ => {}
   91     91   
            }
   92     92   
            Ok(())
   93     93   
        })?;
          94  +
        builder.key = builder.key.or(Some(String::new()));
          95  +
        builder.value = builder.value.or(Some(String::new()));
   94     96   
        builder
   95     97   
            .build()
   96     98   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   97     99   
    }
   98    100   
}
         101  +
impl StorageLensTag {
         102  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         103  +
    pub fn deserialize_with_response(
         104  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         105  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         106  +
        _status: u16,
         107  +
        _body: &[u8],
         108  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         109  +
        Self::deserialize(deserializer)
         110  +
    }
         111  +
}
   99    112   
impl StorageLensTag {
  100    113   
    /// Creates a new builder-style object to manufacture [`StorageLensTag`](crate::types::StorageLensTag).
  101    114   
    pub fn builder() -> crate::types::builders::StorageLensTagBuilder {
  102    115   
        crate::types::builders::StorageLensTagBuilder::default()
  103    116   
    }
  104    117   
}
  105    118   
  106    119   
/// A builder for [`StorageLensTag`](crate::types::StorageLensTag).
  107    120   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  108    121   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_tag.rs

@@ -1,1 +124,137 @@
   19     19   
    pub fn value(&self) -> &str {
   20     20   
        use std::ops::Deref;
   21     21   
        self.value.deref()
   22     22   
    }
   23     23   
}
   24     24   
static TAG_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3control#Tag", "com.amazonaws.s3control", "Tag");
   26     26   
static TAG_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3control#Tag$Key", "com.amazonaws.s3control", "Tag"),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "key",
          29  +
    "Key",
   30     30   
    0,
   31     31   
);
   32     32   
static TAG_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3control#Tag$Value", "com.amazonaws.s3control", "Tag"),
   34     34   
    ::aws_smithy_schema::ShapeType::String,
   35         -
    "value",
          35  +
    "Value",
   36     36   
    1,
   37     37   
);
   38     38   
static TAG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    TAG_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&TAG_MEMBER_KEY, &TAG_MEMBER_VALUE],
   42     42   
);
   43     43   
impl Tag {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TAG_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for Tag {
   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   
        {
   54     54   
            let val = &self.key;
   55     55   
            ser.write_string(&TAG_MEMBER_KEY, val)?;
   56     56   
        }
   57     57   
        {
   58     58   
            let val = &self.value;
   59     59   
            ser.write_string(&TAG_MEMBER_VALUE, val)?;
   60     60   
        }
   61     61   
        Ok(())
   62     62   
    }
   63     63   
}
   64     64   
impl Tag {
   65     65   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   66         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   67         -
        deserializer: &mut D,
          66  +
    pub fn deserialize(
          67  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   68     68   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   69     69   
        #[allow(unused_variables, unused_mut)]
   70     70   
        let mut builder = Self::builder();
   71     71   
        #[allow(
   72     72   
            unused_variables,
   73     73   
            unreachable_code,
   74     74   
            clippy::single_match,
   75     75   
            clippy::match_single_binding,
   76     76   
            clippy::diverging_sub_expression
   77     77   
        )]
   78         -
        deserializer.read_struct(&TAG_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&TAG_SCHEMA, &mut |member, deser| {
   79     79   
            match member.member_index() {
   80     80   
                Some(0) => {
   81     81   
                    builder.key = Some(deser.read_string(member)?);
   82     82   
                }
   83     83   
                Some(1) => {
   84     84   
                    builder.value = Some(deser.read_string(member)?);
   85     85   
                }
   86     86   
                _ => {}
   87     87   
            }
   88     88   
            Ok(())
   89     89   
        })?;
          90  +
        builder.key = builder.key.or(Some(String::new()));
          91  +
        builder.value = builder.value.or(Some(String::new()));
   90     92   
        builder
   91     93   
            .build()
   92     94   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   93     95   
    }
   94     96   
}
          97  +
impl Tag {
          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  +
}
   95    108   
impl Tag {
   96    109   
    /// Creates a new builder-style object to manufacture [`Tag`](crate::types::Tag).
   97    110   
    pub fn builder() -> crate::types::builders::TagBuilder {
   98    111   
        crate::types::builders::TagBuilder::default()
   99    112   
    }
  100    113   
}
  101    114   
  102    115   
/// A builder for [`Tag`](crate::types::Tag).
  103    116   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  104    117   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_tagging.rs

@@ -1,1 +117,126 @@
   12     12   
    pub fn tag_set(&self) -> &[crate::types::S3Tag] {
   13     13   
        use std::ops::Deref;
   14     14   
        self.tag_set.deref()
   15     15   
    }
   16     16   
}
   17     17   
static TAGGING_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   18     18   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3control#Tagging", "com.amazonaws.s3control", "Tagging");
   19     19   
static TAGGING_MEMBER_TAG_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   20     20   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3control#Tagging$TagSet", "com.amazonaws.s3control", "Tagging"),
   21     21   
    ::aws_smithy_schema::ShapeType::List,
   22         -
    "tag_set",
          22  +
    "TagSet",
   23     23   
    0,
   24     24   
);
   25     25   
static TAGGING_SCHEMA: ::aws_smithy_schema::Schema =
   26     26   
    ::aws_smithy_schema::Schema::new_struct(TAGGING_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[&TAGGING_MEMBER_TAG_SET]);
   27     27   
impl Tagging {
   28     28   
    /// The schema for this shape.
   29     29   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TAGGING_SCHEMA;
   30     30   
}
   31     31   
impl ::aws_smithy_schema::serde::SerializableStruct for Tagging {
   32     32   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   33     33   
    fn serialize_members(
   34     34   
        &self,
   35     35   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   36     36   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   37     37   
        {
   38     38   
            let val = &self.tag_set;
   39     39   
   40     40   
            ser.write_list(&TAGGING_MEMBER_TAG_SET, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   41     41   
                for item in val {
   42     42   
                    ser.write_struct(crate::types::S3Tag::SCHEMA, item)?;
   43     43   
                }
   44     44   
                Ok(())
   45     45   
            })?;
   46     46   
        }
   47     47   
        Ok(())
   48     48   
    }
   49     49   
}
   50     50   
impl Tagging {
   51     51   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   52         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   53         -
        deserializer: &mut D,
          52  +
    pub fn deserialize(
          53  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   54     54   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   55     55   
        #[allow(unused_variables, unused_mut)]
   56     56   
        let mut builder = Self::builder();
   57     57   
        #[allow(
   58     58   
            unused_variables,
   59     59   
            unreachable_code,
   60     60   
            clippy::single_match,
   61     61   
            clippy::match_single_binding,
   62     62   
            clippy::diverging_sub_expression
   63     63   
        )]
   64         -
        deserializer.read_struct(&TAGGING_SCHEMA, (), |_, member, deser| {
          64  +
        deserializer.read_struct(&TAGGING_SCHEMA, &mut |member, deser| {
   65     65   
            match member.member_index() {
   66     66   
                Some(0) => {
   67     67   
                    builder.tag_set = Some({
   68         -
                        let container = if let Some(cap) = deser.container_size() {
   69         -
                            Vec::with_capacity(cap)
   70         -
                        } else {
   71         -
                            Vec::new()
   72         -
                        };
   73         -
                        deser.read_list(member, container, |mut list, deser| {
   74         -
                            list.push(crate::types::S3Tag::deserialize(deser)?);
   75         -
                            Ok(list)
   76         -
                        })?
          68  +
                        let mut container = Vec::new();
          69  +
                        deser.read_list(member, &mut |deser| {
          70  +
                            container.push(crate::types::S3Tag::deserialize(deser)?);
          71  +
                            Ok(())
          72  +
                        })?;
          73  +
                        container
   77     74   
                    });
   78     75   
                }
   79     76   
                _ => {}
   80     77   
            }
   81     78   
            Ok(())
   82     79   
        })?;
          80  +
        builder.tag_set = builder.tag_set.or(Some(Vec::new()));
   83     81   
        builder
   84     82   
            .build()
   85     83   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   86     84   
    }
   87     85   
}
          86  +
impl Tagging {
          87  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          88  +
    pub fn deserialize_with_response(
          89  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          90  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          91  +
        _status: u16,
          92  +
        _body: &[u8],
          93  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          94  +
        Self::deserialize(deserializer)
          95  +
    }
          96  +
}
   88     97   
impl Tagging {
   89     98   
    /// Creates a new builder-style object to manufacture [`Tagging`](crate::types::Tagging).
   90     99   
    pub fn builder() -> crate::types::builders::TaggingBuilder {
   91    100   
        crate::types::builders::TaggingBuilder::default()
   92    101   
    }
   93    102   
}
   94    103   
   95    104   
/// A builder for [`Tagging`](crate::types::Tagging).
   96    105   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   97    106   
#[non_exhaustive]