AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36

Files changed:

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

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

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

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/types/_ssec_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 SsecFilter {
   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(&SSECFILTER_SCHEMA, (), |_, member, deser| {
          38  +
        deserializer.read_struct(&SSECFILTER_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 SsecFilter {
          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 SsecFilter {
   48     59   
    /// Creates a new builder-style object to manufacture [`SsecFilter`](crate::types::SsecFilter).
   49     60   
    pub fn builder() -> crate::types::builders::SsecFilterBuilder {
   50     61   
        crate::types::builders::SsecFilterBuilder::default()
   51     62   
    }
   52     63   
}
   53     64   
   54     65   
/// A builder for [`SsecFilter`](crate::types::SsecFilter).
   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/_ssekms.rs

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

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

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

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

@@ -5,5 +130,141 @@
   25     25   
}
   26     26   
static SSEKMSFILTER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3control#SSEKMSFilter", "com.amazonaws.s3control", "SSEKMSFilter");
   28     28   
static SSEKMSFILTER_MEMBER_KMS_KEY_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   29     29   
    ::aws_smithy_schema::ShapeId::from_static(
   30     30   
        "com.amazonaws.s3control#SSEKMSFilter$KmsKeyArn",
   31     31   
        "com.amazonaws.s3control",
   32     32   
        "SSEKMSFilter",
   33     33   
    ),
   34     34   
    ::aws_smithy_schema::ShapeType::String,
   35         -
    "kms_key_arn",
          35  +
    "KmsKeyArn",
   36     36   
    0,
   37     37   
);
   38     38   
static SSEKMSFILTER_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.s3control#SSEKMSFilter$BucketKeyEnabled",
   41     41   
        "com.amazonaws.s3control",
   42     42   
        "SSEKMSFilter",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::Boolean,
   45         -
    "bucket_key_enabled",
          45  +
    "BucketKeyEnabled",
   46     46   
    1,
   47     47   
);
   48     48   
static SSEKMSFILTER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    SSEKMSFILTER_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[&SSEKMSFILTER_MEMBER_KMS_KEY_ARN, &SSEKMSFILTER_MEMBER_BUCKET_KEY_ENABLED],
   52     52   
);
   53     53   
impl SsekmsFilter {
   54     54   
    /// The schema for this shape.
   55     55   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SSEKMSFILTER_SCHEMA;
   56     56   
}
   57     57   
impl ::aws_smithy_schema::serde::SerializableStruct for SsekmsFilter {
   58     58   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   59     59   
    fn serialize_members(
   60     60   
        &self,
   61     61   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   62     62   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   63     63   
        if let Some(ref val) = self.kms_key_arn {
   64     64   
            ser.write_string(&SSEKMSFILTER_MEMBER_KMS_KEY_ARN, val)?;
   65     65   
        }
   66     66   
        if let Some(ref val) = self.bucket_key_enabled {
   67     67   
            ser.write_boolean(&SSEKMSFILTER_MEMBER_BUCKET_KEY_ENABLED, *val)?;
   68     68   
        }
   69     69   
        Ok(())
   70     70   
    }
   71     71   
}
   72     72   
impl SsekmsFilter {
   73     73   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   74         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   75         -
        deserializer: &mut D,
          74  +
    pub fn deserialize(
          75  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   76     76   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   77     77   
        #[allow(unused_variables, unused_mut)]
   78     78   
        let mut builder = Self::builder();
   79     79   
        #[allow(
   80     80   
            unused_variables,
   81     81   
            unreachable_code,
   82     82   
            clippy::single_match,
   83     83   
            clippy::match_single_binding,
   84     84   
            clippy::diverging_sub_expression
   85     85   
        )]
   86         -
        deserializer.read_struct(&SSEKMSFILTER_SCHEMA, (), |_, member, deser| {
          86  +
        deserializer.read_struct(&SSEKMSFILTER_SCHEMA, &mut |member, deser| {
   87     87   
            match member.member_index() {
   88     88   
                Some(0) => {
   89     89   
                    builder.kms_key_arn = Some(deser.read_string(member)?);
   90     90   
                }
   91     91   
                Some(1) => {
   92     92   
                    builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
   93     93   
                }
   94     94   
                _ => {}
   95     95   
            }
   96     96   
            Ok(())
   97     97   
        })?;
   98     98   
        Ok(builder.build())
   99     99   
    }
  100    100   
}
         101  +
impl SsekmsFilter {
         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  +
}
  101    112   
impl SsekmsFilter {
  102    113   
    /// Creates a new builder-style object to manufacture [`SsekmsFilter`](crate::types::SsekmsFilter).
  103    114   
    pub fn builder() -> crate::types::builders::SsekmsFilterBuilder {
  104    115   
        crate::types::builders::SsekmsFilterBuilder::default()
  105    116   
    }
  106    117   
}
  107    118   
  108    119   
/// A builder for [`SsekmsFilter`](crate::types::SsekmsFilter).
  109    120   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  110    121   
#[non_exhaustive]

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]