AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406 (ignoring whitespace)

Files changed:

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

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

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

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

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

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

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

@@ -38,38 +253,264 @@
   58     58   
    }
   59     59   
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> checksum of the part. This checksum is present if the object was uploaded with the <code>SHA256</code> checksum algorithm. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   60     60   
    pub fn checksum_sha256(&self) -> ::std::option::Option<&str> {
   61     61   
        self.checksum_sha256.as_deref()
   62     62   
    }
   63     63   
}
   64     64   
static PART_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Part", "com.amazonaws.s3", "Part");
   65     65   
static PART_MEMBER_PART_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Part$PartNumber", "com.amazonaws.s3", "Part"),
   67     67   
    ::aws_smithy_schema::ShapeType::Integer,
   68         -
    "part_number",
          68  +
    "PartNumber",
   69     69   
    0,
   70     70   
);
   71     71   
static PART_MEMBER_LAST_MODIFIED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Part$LastModified", "com.amazonaws.s3", "Part"),
   73     73   
    ::aws_smithy_schema::ShapeType::Timestamp,
   74         -
    "last_modified",
          74  +
    "LastModified",
   75     75   
    1,
   76     76   
);
   77     77   
static PART_MEMBER_E_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Part$ETag", "com.amazonaws.s3", "Part"),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "e_tag",
          80  +
    "ETag",
   81     81   
    2,
   82     82   
);
   83     83   
static PART_MEMBER_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Part$Size", "com.amazonaws.s3", "Part"),
   85     85   
    ::aws_smithy_schema::ShapeType::Long,
   86         -
    "size",
          86  +
    "Size",
   87     87   
    3,
   88     88   
);
   89     89   
static PART_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Part$ChecksumCRC32", "com.amazonaws.s3", "Part"),
   91     91   
    ::aws_smithy_schema::ShapeType::String,
   92         -
    "checksum_crc32",
          92  +
    "ChecksumCRC32",
   93     93   
    4,
   94     94   
);
   95     95   
static PART_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Part$ChecksumCRC32C", "com.amazonaws.s3", "Part"),
   97     97   
    ::aws_smithy_schema::ShapeType::String,
   98         -
    "checksum_crc32_c",
          98  +
    "ChecksumCRC32C",
   99     99   
    5,
  100    100   
);
  101    101   
static PART_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Part$ChecksumCRC64NVME", "com.amazonaws.s3", "Part"),
  103    103   
    ::aws_smithy_schema::ShapeType::String,
  104         -
    "checksum_crc64_nvme",
         104  +
    "ChecksumCRC64NVME",
  105    105   
    6,
  106    106   
);
  107    107   
static PART_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Part$ChecksumSHA1", "com.amazonaws.s3", "Part"),
  109    109   
    ::aws_smithy_schema::ShapeType::String,
  110         -
    "checksum_sha1",
         110  +
    "ChecksumSHA1",
  111    111   
    7,
  112    112   
);
  113    113   
static PART_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Part$ChecksumSHA256", "com.amazonaws.s3", "Part"),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "checksum_sha256",
         116  +
    "ChecksumSHA256",
  117    117   
    8,
  118    118   
);
  119    119   
static PART_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  120    120   
    PART_SCHEMA_ID,
  121    121   
    ::aws_smithy_schema::ShapeType::Structure,
  122    122   
    &[
  123    123   
        &PART_MEMBER_PART_NUMBER,
  124    124   
        &PART_MEMBER_LAST_MODIFIED,
  125    125   
        &PART_MEMBER_E_TAG,
  126    126   
        &PART_MEMBER_SIZE,
  127    127   
        &PART_MEMBER_CHECKSUM_CRC32,
  128    128   
        &PART_MEMBER_CHECKSUM_CRC32_C,
  129    129   
        &PART_MEMBER_CHECKSUM_CRC64_NVME,
  130    130   
        &PART_MEMBER_CHECKSUM_SHA1,
  131    131   
        &PART_MEMBER_CHECKSUM_SHA256,
  132    132   
    ],
  133    133   
);
  134    134   
impl Part {
  135    135   
    /// The schema for this shape.
  136    136   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PART_SCHEMA;
  137    137   
}
  138    138   
impl ::aws_smithy_schema::serde::SerializableStruct for Part {
  139    139   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  140    140   
    fn serialize_members(
  141    141   
        &self,
  142    142   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  143    143   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  144    144   
        if let Some(ref val) = self.part_number {
  145    145   
            ser.write_integer(&PART_MEMBER_PART_NUMBER, *val)?;
  146    146   
        }
  147    147   
        if let Some(ref val) = self.last_modified {
  148    148   
            ser.write_timestamp(&PART_MEMBER_LAST_MODIFIED, val)?;
  149    149   
        }
  150    150   
        if let Some(ref val) = self.e_tag {
  151    151   
            ser.write_string(&PART_MEMBER_E_TAG, val)?;
  152    152   
        }
  153    153   
        if let Some(ref val) = self.size {
  154    154   
            ser.write_long(&PART_MEMBER_SIZE, *val)?;
  155    155   
        }
  156    156   
        if let Some(ref val) = self.checksum_crc32 {
  157    157   
            ser.write_string(&PART_MEMBER_CHECKSUM_CRC32, val)?;
  158    158   
        }
  159    159   
        if let Some(ref val) = self.checksum_crc32_c {
  160    160   
            ser.write_string(&PART_MEMBER_CHECKSUM_CRC32_C, val)?;
  161    161   
        }
  162    162   
        if let Some(ref val) = self.checksum_crc64_nvme {
  163    163   
            ser.write_string(&PART_MEMBER_CHECKSUM_CRC64_NVME, val)?;
  164    164   
        }
  165    165   
        if let Some(ref val) = self.checksum_sha1 {
  166    166   
            ser.write_string(&PART_MEMBER_CHECKSUM_SHA1, val)?;
  167    167   
        }
  168    168   
        if let Some(ref val) = self.checksum_sha256 {
  169    169   
            ser.write_string(&PART_MEMBER_CHECKSUM_SHA256, val)?;
  170    170   
        }
  171    171   
        Ok(())
  172    172   
    }
  173    173   
}
  174    174   
impl Part {
  175    175   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  176         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  177         -
        deserializer: &mut D,
         176  +
    pub fn deserialize(
         177  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  178    178   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  179    179   
        #[allow(unused_variables, unused_mut)]
  180    180   
        let mut builder = Self::builder();
  181    181   
        #[allow(
  182    182   
            unused_variables,
  183    183   
            unreachable_code,
  184    184   
            clippy::single_match,
  185    185   
            clippy::match_single_binding,
  186    186   
            clippy::diverging_sub_expression
  187    187   
        )]
  188         -
        deserializer.read_struct(&PART_SCHEMA, (), |_, member, deser| {
         188  +
        deserializer.read_struct(&PART_SCHEMA, &mut |member, deser| {
  189    189   
            match member.member_index() {
  190    190   
                Some(0) => {
  191    191   
                    builder.part_number = Some(deser.read_integer(member)?);
  192    192   
                }
  193    193   
                Some(1) => {
  194    194   
                    builder.last_modified = Some(deser.read_timestamp(member)?);
  195    195   
                }
  196    196   
                Some(2) => {
  197    197   
                    builder.e_tag = Some(deser.read_string(member)?);
  198    198   
                }
  199    199   
                Some(3) => {
  200    200   
                    builder.size = Some(deser.read_long(member)?);
  201    201   
                }
  202    202   
                Some(4) => {
  203    203   
                    builder.checksum_crc32 = Some(deser.read_string(member)?);
  204    204   
                }
  205    205   
                Some(5) => {
  206    206   
                    builder.checksum_crc32_c = Some(deser.read_string(member)?);
  207    207   
                }
  208    208   
                Some(6) => {
  209    209   
                    builder.checksum_crc64_nvme = Some(deser.read_string(member)?);
  210    210   
                }
  211    211   
                Some(7) => {
  212    212   
                    builder.checksum_sha1 = Some(deser.read_string(member)?);
  213    213   
                }
  214    214   
                Some(8) => {
  215    215   
                    builder.checksum_sha256 = Some(deser.read_string(member)?);
  216    216   
                }
  217    217   
                _ => {}
  218    218   
            }
  219    219   
            Ok(())
  220    220   
        })?;
  221    221   
        Ok(builder.build())
  222    222   
    }
  223    223   
}
         224  +
impl Part {
         225  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         226  +
    pub fn deserialize_with_response(
         227  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         228  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         229  +
        _status: u16,
         230  +
        _body: &[u8],
         231  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         232  +
        Self::deserialize(deserializer)
         233  +
    }
         234  +
}
  224    235   
impl Part {
  225    236   
    /// Creates a new builder-style object to manufacture [`Part`](crate::types::Part).
  226    237   
    pub fn builder() -> crate::types::builders::PartBuilder {
  227    238   
        crate::types::builders::PartBuilder::default()
  228    239   
    }
  229    240   
}
  230    241   
  231    242   
/// A builder for [`Part`](crate::types::Part).
  232    243   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  233    244   
#[non_exhaustive]

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

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

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

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

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

@@ -3,3 +140,151 @@
   23     23   
    /// <p>The current number of bytes of records payload data returned.</p>
   24     24   
    pub fn bytes_returned(&self) -> ::std::option::Option<i64> {
   25     25   
        self.bytes_returned
   26     26   
    }
   27     27   
}
   28     28   
static PROGRESS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   29     29   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Progress", "com.amazonaws.s3", "Progress");
   30     30   
static PROGRESS_MEMBER_BYTES_SCANNED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Progress$BytesScanned", "com.amazonaws.s3", "Progress"),
   32     32   
    ::aws_smithy_schema::ShapeType::Long,
   33         -
    "bytes_scanned",
          33  +
    "BytesScanned",
   34     34   
    0,
   35     35   
);
   36     36   
static PROGRESS_MEMBER_BYTES_PROCESSED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Progress$BytesProcessed", "com.amazonaws.s3", "Progress"),
   38     38   
    ::aws_smithy_schema::ShapeType::Long,
   39         -
    "bytes_processed",
          39  +
    "BytesProcessed",
   40     40   
    1,
   41     41   
);
   42     42   
static PROGRESS_MEMBER_BYTES_RETURNED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Progress$BytesReturned", "com.amazonaws.s3", "Progress"),
   44     44   
    ::aws_smithy_schema::ShapeType::Long,
   45         -
    "bytes_returned",
          45  +
    "BytesReturned",
   46     46   
    2,
   47     47   
);
   48     48   
static PROGRESS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    PROGRESS_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[
   52     52   
        &PROGRESS_MEMBER_BYTES_SCANNED,
   53     53   
        &PROGRESS_MEMBER_BYTES_PROCESSED,
   54     54   
        &PROGRESS_MEMBER_BYTES_RETURNED,
   55     55   
    ],
   56     56   
);
   57     57   
impl Progress {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PROGRESS_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for Progress {
   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.bytes_scanned {
   68     68   
            ser.write_long(&PROGRESS_MEMBER_BYTES_SCANNED, *val)?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.bytes_processed {
   71     71   
            ser.write_long(&PROGRESS_MEMBER_BYTES_PROCESSED, *val)?;
   72     72   
        }
   73     73   
        if let Some(ref val) = self.bytes_returned {
   74     74   
            ser.write_long(&PROGRESS_MEMBER_BYTES_RETURNED, *val)?;
   75     75   
        }
   76     76   
        Ok(())
   77     77   
    }
   78     78   
}
   79     79   
impl Progress {
   80     80   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   81         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   82         -
        deserializer: &mut D,
          81  +
    pub fn deserialize(
          82  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   83     83   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   84     84   
        #[allow(unused_variables, unused_mut)]
   85     85   
        let mut builder = Self::builder();
   86     86   
        #[allow(
   87     87   
            unused_variables,
   88     88   
            unreachable_code,
   89     89   
            clippy::single_match,
   90     90   
            clippy::match_single_binding,
   91     91   
            clippy::diverging_sub_expression
   92     92   
        )]
   93         -
        deserializer.read_struct(&PROGRESS_SCHEMA, (), |_, member, deser| {
          93  +
        deserializer.read_struct(&PROGRESS_SCHEMA, &mut |member, deser| {
   94     94   
            match member.member_index() {
   95     95   
                Some(0) => {
   96     96   
                    builder.bytes_scanned = Some(deser.read_long(member)?);
   97     97   
                }
   98     98   
                Some(1) => {
   99     99   
                    builder.bytes_processed = Some(deser.read_long(member)?);
  100    100   
                }
  101    101   
                Some(2) => {
  102    102   
                    builder.bytes_returned = Some(deser.read_long(member)?);
  103    103   
                }
  104    104   
                _ => {}
  105    105   
            }
  106    106   
            Ok(())
  107    107   
        })?;
  108    108   
        Ok(builder.build())
  109    109   
    }
  110    110   
}
         111  +
impl Progress {
         112  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         113  +
    pub fn deserialize_with_response(
         114  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         115  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         116  +
        _status: u16,
         117  +
        _body: &[u8],
         118  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         119  +
        Self::deserialize(deserializer)
         120  +
    }
         121  +
}
  111    122   
impl Progress {
  112    123   
    /// Creates a new builder-style object to manufacture [`Progress`](crate::types::Progress).
  113    124   
    pub fn builder() -> crate::types::builders::ProgressBuilder {
  114    125   
        crate::types::builders::ProgressBuilder::default()
  115    126   
    }
  116    127   
}
  117    128   
  118    129   
/// A builder for [`Progress`](crate::types::Progress).
  119    130   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  120    131   
#[non_exhaustive]

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

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

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

@@ -40,40 +206,217 @@
   60     60   
    "com.amazonaws.s3",
   61     61   
    "PublicAccessBlockConfiguration",
   62     62   
);
   63     63   
static PUBLICACCESSBLOCKCONFIGURATION_MEMBER_BLOCK_PUBLIC_ACLS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.s3#PublicAccessBlockConfiguration$BlockPublicAcls",
   66     66   
        "com.amazonaws.s3",
   67     67   
        "PublicAccessBlockConfiguration",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::Boolean,
   70         -
    "block_public_acls",
          70  +
    "BlockPublicAcls",
   71     71   
    0,
   72     72   
)
   73     73   
.with_xml_name("BlockPublicAcls");
   74     74   
static PUBLICACCESSBLOCKCONFIGURATION_MEMBER_IGNORE_PUBLIC_ACLS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "com.amazonaws.s3#PublicAccessBlockConfiguration$IgnorePublicAcls",
   77     77   
        "com.amazonaws.s3",
   78     78   
        "PublicAccessBlockConfiguration",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::Boolean,
   81         -
    "ignore_public_acls",
          81  +
    "IgnorePublicAcls",
   82     82   
    1,
   83     83   
)
   84     84   
.with_xml_name("IgnorePublicAcls");
   85     85   
static PUBLICACCESSBLOCKCONFIGURATION_MEMBER_BLOCK_PUBLIC_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "com.amazonaws.s3#PublicAccessBlockConfiguration$BlockPublicPolicy",
   88     88   
        "com.amazonaws.s3",
   89     89   
        "PublicAccessBlockConfiguration",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::Boolean,
   92         -
    "block_public_policy",
          92  +
    "BlockPublicPolicy",
   93     93   
    2,
   94     94   
)
   95     95   
.with_xml_name("BlockPublicPolicy");
   96     96   
static PUBLICACCESSBLOCKCONFIGURATION_MEMBER_RESTRICT_PUBLIC_BUCKETS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static(
   98     98   
        "com.amazonaws.s3#PublicAccessBlockConfiguration$RestrictPublicBuckets",
   99     99   
        "com.amazonaws.s3",
  100    100   
        "PublicAccessBlockConfiguration",
  101    101   
    ),
  102    102   
    ::aws_smithy_schema::ShapeType::Boolean,
  103         -
    "restrict_public_buckets",
         103  +
    "RestrictPublicBuckets",
  104    104   
    3,
  105    105   
)
  106    106   
.with_xml_name("RestrictPublicBuckets");
  107    107   
static PUBLICACCESSBLOCKCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  108    108   
    PUBLICACCESSBLOCKCONFIGURATION_SCHEMA_ID,
  109    109   
    ::aws_smithy_schema::ShapeType::Structure,
  110    110   
    &[
  111    111   
        &PUBLICACCESSBLOCKCONFIGURATION_MEMBER_BLOCK_PUBLIC_ACLS,
  112    112   
        &PUBLICACCESSBLOCKCONFIGURATION_MEMBER_IGNORE_PUBLIC_ACLS,
  113    113   
        &PUBLICACCESSBLOCKCONFIGURATION_MEMBER_BLOCK_PUBLIC_POLICY,
  114    114   
        &PUBLICACCESSBLOCKCONFIGURATION_MEMBER_RESTRICT_PUBLIC_BUCKETS,
  115    115   
    ],
  116    116   
);
  117    117   
impl PublicAccessBlockConfiguration {
  118    118   
    /// The schema for this shape.
  119    119   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUBLICACCESSBLOCKCONFIGURATION_SCHEMA;
  120    120   
}
  121    121   
impl ::aws_smithy_schema::serde::SerializableStruct for PublicAccessBlockConfiguration {
  122    122   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  123    123   
    fn serialize_members(
  124    124   
        &self,
  125    125   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  126    126   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  127    127   
        if let Some(ref val) = self.block_public_acls {
  128    128   
            ser.write_boolean(&PUBLICACCESSBLOCKCONFIGURATION_MEMBER_BLOCK_PUBLIC_ACLS, *val)?;
  129    129   
        }
  130    130   
        if let Some(ref val) = self.ignore_public_acls {
  131    131   
            ser.write_boolean(&PUBLICACCESSBLOCKCONFIGURATION_MEMBER_IGNORE_PUBLIC_ACLS, *val)?;
  132    132   
        }
  133    133   
        if let Some(ref val) = self.block_public_policy {
  134    134   
            ser.write_boolean(&PUBLICACCESSBLOCKCONFIGURATION_MEMBER_BLOCK_PUBLIC_POLICY, *val)?;
  135    135   
        }
  136    136   
        if let Some(ref val) = self.restrict_public_buckets {
  137    137   
            ser.write_boolean(&PUBLICACCESSBLOCKCONFIGURATION_MEMBER_RESTRICT_PUBLIC_BUCKETS, *val)?;
  138    138   
        }
  139    139   
        Ok(())
  140    140   
    }
  141    141   
}
  142    142   
impl PublicAccessBlockConfiguration {
  143    143   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  144         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  145         -
        deserializer: &mut D,
         144  +
    pub fn deserialize(
         145  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  146    146   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  147    147   
        #[allow(unused_variables, unused_mut)]
  148    148   
        let mut builder = Self::builder();
  149    149   
        #[allow(
  150    150   
            unused_variables,
  151    151   
            unreachable_code,
  152    152   
            clippy::single_match,
  153    153   
            clippy::match_single_binding,
  154    154   
            clippy::diverging_sub_expression
  155    155   
        )]
  156         -
        deserializer.read_struct(&PUBLICACCESSBLOCKCONFIGURATION_SCHEMA, (), |_, member, deser| {
         156  +
        deserializer.read_struct(&PUBLICACCESSBLOCKCONFIGURATION_SCHEMA, &mut |member, deser| {
  157    157   
            match member.member_index() {
  158    158   
                Some(0) => {
  159    159   
                    builder.block_public_acls = Some(deser.read_boolean(member)?);
  160    160   
                }
  161    161   
                Some(1) => {
  162    162   
                    builder.ignore_public_acls = Some(deser.read_boolean(member)?);
  163    163   
                }
  164    164   
                Some(2) => {
  165    165   
                    builder.block_public_policy = Some(deser.read_boolean(member)?);
  166    166   
                }
  167    167   
                Some(3) => {
  168    168   
                    builder.restrict_public_buckets = Some(deser.read_boolean(member)?);
  169    169   
                }
  170    170   
                _ => {}
  171    171   
            }
  172    172   
            Ok(())
  173    173   
        })?;
  174    174   
        Ok(builder.build())
  175    175   
    }
  176    176   
}
         177  +
impl PublicAccessBlockConfiguration {
         178  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         179  +
    pub fn deserialize_with_response(
         180  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         181  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         182  +
        _status: u16,
         183  +
        _body: &[u8],
         184  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         185  +
        Self::deserialize(deserializer)
         186  +
    }
         187  +
}
  177    188   
impl PublicAccessBlockConfiguration {
  178    189   
    /// Creates a new builder-style object to manufacture [`PublicAccessBlockConfiguration`](crate::types::PublicAccessBlockConfiguration).
  179    190   
    pub fn builder() -> crate::types::builders::PublicAccessBlockConfigurationBuilder {
  180    191   
        crate::types::builders::PublicAccessBlockConfigurationBuilder::default()
  181    192   
    }
  182    193   
}
  183    194   
  184    195   
/// A builder for [`PublicAccessBlockConfiguration`](crate::types::PublicAccessBlockConfiguration).
  185    196   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  186    197   
#[non_exhaustive]

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

@@ -11,11 +187,197 @@
   31     31   
    /// <p>Specifies object key name filtering rules. For information about key name filtering, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-how-to-filtering.html">Configuring event notifications using object key name filtering</a> in the <i>Amazon S3 User Guide</i>.</p>
   32     32   
    pub fn filter(&self) -> ::std::option::Option<&crate::types::NotificationConfigurationFilter> {
   33     33   
        self.filter.as_ref()
   34     34   
    }
   35     35   
}
   36     36   
static QUEUECONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#QueueConfiguration", "com.amazonaws.s3", "QueueConfiguration");
   38     38   
static QUEUECONFIGURATION_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#QueueConfiguration$Id", "com.amazonaws.s3", "QueueConfiguration"),
   40     40   
    ::aws_smithy_schema::ShapeType::String,
   41         -
    "id",
          41  +
    "Id",
   42     42   
    0,
   43     43   
);
   44     44   
static QUEUECONFIGURATION_MEMBER_QUEUE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#QueueConfiguration$QueueArn", "com.amazonaws.s3", "QueueConfiguration"),
   46     46   
    ::aws_smithy_schema::ShapeType::String,
   47         -
    "queue_arn",
          47  +
    "QueueArn",
   48     48   
    1,
   49     49   
)
   50     50   
.with_xml_name("Queue");
   51     51   
static QUEUECONFIGURATION_MEMBER_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#QueueConfiguration$Events", "com.amazonaws.s3", "QueueConfiguration"),
   53     53   
    ::aws_smithy_schema::ShapeType::List,
   54         -
    "events",
          54  +
    "Events",
   55     55   
    2,
   56     56   
)
   57     57   
.with_xml_name("Event")
   58     58   
.with_xml_flattened();
   59     59   
static QUEUECONFIGURATION_MEMBER_FILTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#QueueConfiguration$Filter", "com.amazonaws.s3", "QueueConfiguration"),
   61     61   
    ::aws_smithy_schema::ShapeType::Structure,
   62         -
    "filter",
          62  +
    "Filter",
   63     63   
    3,
   64     64   
);
   65     65   
static QUEUECONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   66     66   
    QUEUECONFIGURATION_SCHEMA_ID,
   67     67   
    ::aws_smithy_schema::ShapeType::Structure,
   68     68   
    &[
   69     69   
        &QUEUECONFIGURATION_MEMBER_ID,
   70     70   
        &QUEUECONFIGURATION_MEMBER_QUEUE_ARN,
   71     71   
        &QUEUECONFIGURATION_MEMBER_EVENTS,
   72     72   
        &QUEUECONFIGURATION_MEMBER_FILTER,
   73     73   
    ],
   74     74   
);
   75     75   
impl QueueConfiguration {
   76     76   
    /// The schema for this shape.
   77     77   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUEUECONFIGURATION_SCHEMA;
   78     78   
}
   79     79   
impl ::aws_smithy_schema::serde::SerializableStruct for QueueConfiguration {
   80     80   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   81     81   
    fn serialize_members(
   82     82   
        &self,
   83     83   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   84     84   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   85     85   
        if let Some(ref val) = self.id {
   86     86   
            ser.write_string(&QUEUECONFIGURATION_MEMBER_ID, val)?;
   87     87   
        }
   88     88   
        {
   89     89   
            let val = &self.queue_arn;
   90     90   
            ser.write_string(&QUEUECONFIGURATION_MEMBER_QUEUE_ARN, val)?;
   91     91   
        }
   92     92   
        {
   93     93   
            let val = &self.events;
   94     94   
   95     95   
            ser.write_list(
   96     96   
                &QUEUECONFIGURATION_MEMBER_EVENTS,
   97     97   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   98     98   
                    for item in val {
   99     99   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
  100    100   
                    }
  101    101   
                    Ok(())
  102    102   
                },
  103    103   
            )?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.filter {
  106    106   
            ser.write_struct(&QUEUECONFIGURATION_MEMBER_FILTER, val)?;
  107    107   
        }
  108    108   
        Ok(())
  109    109   
    }
  110    110   
}
  111    111   
impl QueueConfiguration {
  112    112   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  113         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  114         -
        deserializer: &mut D,
         113  +
    pub fn deserialize(
         114  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  115    115   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  116    116   
        #[allow(unused_variables, unused_mut)]
  117    117   
        let mut builder = Self::builder();
  118    118   
        #[allow(
  119    119   
            unused_variables,
  120    120   
            unreachable_code,
  121    121   
            clippy::single_match,
  122    122   
            clippy::match_single_binding,
  123    123   
            clippy::diverging_sub_expression
  124    124   
        )]
  125         -
        deserializer.read_struct(&QUEUECONFIGURATION_SCHEMA, (), |_, member, deser| {
         125  +
        deserializer.read_struct(&QUEUECONFIGURATION_SCHEMA, &mut |member, deser| {
  126    126   
            match member.member_index() {
  127    127   
                Some(0) => {
  128    128   
                    builder.id = Some(deser.read_string(member)?);
  129    129   
                }
  130    130   
                Some(1) => {
  131    131   
                    builder.queue_arn = Some(deser.read_string(member)?);
  132    132   
                }
  133    133   
                Some(2) => {
  134    134   
                    builder.events = Some({
  135         -
                        let container = if let Some(cap) = deser.container_size() {
  136         -
                            Vec::with_capacity(cap)
  137         -
                        } else {
  138         -
                            Vec::new()
  139         -
                        };
  140         -
                        deser.read_list(member, container, |mut list, deser| {
  141         -
                            list.push(crate::types::Event::from(deser.read_string(member)?.as_str()));
  142         -
                            Ok(list)
  143         -
                        })?
         135  +
                        let mut container = Vec::new();
         136  +
                        deser.read_list(member, &mut |deser| {
         137  +
                            container.push(crate::types::Event::from(deser.read_string(member)?.as_str()));
         138  +
                            Ok(())
         139  +
                        })?;
         140  +
                        container
  144    141   
                    });
  145    142   
                }
  146    143   
                Some(3) => {
  147    144   
                    builder.filter = Some(crate::types::NotificationConfigurationFilter::deserialize(deser)?);
  148    145   
                }
  149    146   
                _ => {}
  150    147   
            }
  151    148   
            Ok(())
  152    149   
        })?;
         150  +
        builder.queue_arn = builder.queue_arn.or(Some(String::new()));
         151  +
        builder.events = builder.events.or(Some(Vec::new()));
  153    152   
        builder
  154    153   
            .build()
  155    154   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  156    155   
    }
  157    156   
}
         157  +
impl QueueConfiguration {
         158  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         159  +
    pub fn deserialize_with_response(
         160  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         161  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         162  +
        _status: u16,
         163  +
        _body: &[u8],
         164  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         165  +
        Self::deserialize(deserializer)
         166  +
    }
         167  +
}
  158    168   
impl QueueConfiguration {
  159    169   
    /// Creates a new builder-style object to manufacture [`QueueConfiguration`](crate::types::QueueConfiguration).
  160    170   
    pub fn builder() -> crate::types::builders::QueueConfigurationBuilder {
  161    171   
        crate::types::builders::QueueConfigurationBuilder::default()
  162    172   
    }
  163    173   
}
  164    174   
  165    175   
/// A builder for [`QueueConfiguration`](crate::types::QueueConfiguration).
  166    176   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  167    177   
#[non_exhaustive]

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

@@ -1,1 +121,132 @@
   17     17   
    /// <p>If you enable journal table record expiration, you can set the number of days to retain your journal table records. Journal table records must be retained for a minimum of 7 days. To set this value, specify any whole number from <code>7</code> to <code>2147483647</code>. For example, to retain your journal table records for one year, set this value to <code>365</code>.</p>
   18     18   
    pub fn days(&self) -> ::std::option::Option<i32> {
   19     19   
        self.days
   20     20   
    }
   21     21   
}
   22     22   
static RECORDEXPIRATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#RecordExpiration", "com.amazonaws.s3", "RecordExpiration");
   24     24   
static RECORDEXPIRATION_MEMBER_EXPIRATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#RecordExpiration$Expiration", "com.amazonaws.s3", "RecordExpiration"),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "expiration",
          27  +
    "Expiration",
   28     28   
    0,
   29     29   
);
   30     30   
static RECORDEXPIRATION_MEMBER_DAYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#RecordExpiration$Days", "com.amazonaws.s3", "RecordExpiration"),
   32     32   
    ::aws_smithy_schema::ShapeType::Integer,
   33         -
    "days",
          33  +
    "Days",
   34     34   
    1,
   35     35   
);
   36     36   
static RECORDEXPIRATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   37     37   
    RECORDEXPIRATION_SCHEMA_ID,
   38     38   
    ::aws_smithy_schema::ShapeType::Structure,
   39     39   
    &[&RECORDEXPIRATION_MEMBER_EXPIRATION, &RECORDEXPIRATION_MEMBER_DAYS],
   40     40   
);
   41     41   
impl RecordExpiration {
   42     42   
    /// The schema for this shape.
   43     43   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RECORDEXPIRATION_SCHEMA;
   44     44   
}
   45     45   
impl ::aws_smithy_schema::serde::SerializableStruct for RecordExpiration {
   46     46   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   47     47   
    fn serialize_members(
   48     48   
        &self,
   49     49   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   50     50   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   51     51   
        {
   52     52   
            let val = &self.expiration;
   53     53   
            ser.write_string(&RECORDEXPIRATION_MEMBER_EXPIRATION, val.as_str())?;
   54     54   
        }
   55     55   
        if let Some(ref val) = self.days {
   56     56   
            ser.write_integer(&RECORDEXPIRATION_MEMBER_DAYS, *val)?;
   57     57   
        }
   58     58   
        Ok(())
   59     59   
    }
   60     60   
}
   61     61   
impl RecordExpiration {
   62     62   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   63         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   64         -
        deserializer: &mut D,
          63  +
    pub fn deserialize(
          64  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   65     65   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   66     66   
        #[allow(unused_variables, unused_mut)]
   67     67   
        let mut builder = Self::builder();
   68     68   
        #[allow(
   69     69   
            unused_variables,
   70     70   
            unreachable_code,
   71     71   
            clippy::single_match,
   72     72   
            clippy::match_single_binding,
   73     73   
            clippy::diverging_sub_expression
   74     74   
        )]
   75         -
        deserializer.read_struct(&RECORDEXPIRATION_SCHEMA, (), |_, member, deser| {
          75  +
        deserializer.read_struct(&RECORDEXPIRATION_SCHEMA, &mut |member, deser| {
   76     76   
            match member.member_index() {
   77     77   
                Some(0) => {
   78     78   
                    builder.expiration = Some(crate::types::ExpirationState::from(deser.read_string(member)?.as_str()));
   79     79   
                }
   80     80   
                Some(1) => {
   81     81   
                    builder.days = Some(deser.read_integer(member)?);
   82     82   
                }
   83     83   
                _ => {}
   84     84   
            }
   85     85   
            Ok(())
   86     86   
        })?;
   87     87   
        builder
   88     88   
            .build()
   89     89   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   90     90   
    }
   91     91   
}
          92  +
impl RecordExpiration {
          93  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          94  +
    pub fn deserialize_with_response(
          95  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          96  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          97  +
        _status: u16,
          98  +
        _body: &[u8],
          99  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         100  +
        Self::deserialize(deserializer)
         101  +
    }
         102  +
}
   92    103   
impl RecordExpiration {
   93    104   
    /// Creates a new builder-style object to manufacture [`RecordExpiration`](crate::types::RecordExpiration).
   94    105   
    pub fn builder() -> crate::types::builders::RecordExpirationBuilder {
   95    106   
        crate::types::builders::RecordExpirationBuilder::default()
   96    107   
    }
   97    108   
}
   98    109   
   99    110   
/// A builder for [`RecordExpiration`](crate::types::RecordExpiration).
  100    111   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  101    112   
#[non_exhaustive]

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

@@ -1,1 +101,112 @@
   11     11   
    /// <p>The byte array of partial, one or more result records. S3 Select doesn't guarantee that a record will be self-contained in one record frame. To ensure continuous streaming of data, S3 Select might split the same record across multiple record frames instead of aggregating the results in memory. Some S3 clients (for example, the SDK for Java) handle this behavior by creating a <code>ByteStream</code> out of the response by default. Other clients might not handle this behavior by default. In those cases, you must aggregate the results on the client side and parse the response.</p>
   12     12   
    pub fn payload(&self) -> ::std::option::Option<&::aws_smithy_types::Blob> {
   13     13   
        self.payload.as_ref()
   14     14   
    }
   15     15   
}
   16     16   
static RECORDSEVENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#RecordsEvent", "com.amazonaws.s3", "RecordsEvent");
   18     18   
static RECORDSEVENT_MEMBER_PAYLOAD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#RecordsEvent$Payload", "com.amazonaws.s3", "RecordsEvent"),
   20     20   
    ::aws_smithy_schema::ShapeType::Blob,
   21         -
    "payload",
          21  +
    "Payload",
   22     22   
    0,
   23     23   
)
   24     24   
.with_event_payload();
   25     25   
static RECORDSEVENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   26     26   
    RECORDSEVENT_SCHEMA_ID,
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28     28   
    &[&RECORDSEVENT_MEMBER_PAYLOAD],
   29     29   
);
   30     30   
impl RecordsEvent {
   31     31   
    /// The schema for this shape.
   32     32   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RECORDSEVENT_SCHEMA;
   33     33   
}
   34     34   
impl ::aws_smithy_schema::serde::SerializableStruct for RecordsEvent {
   35     35   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   36     36   
    fn serialize_members(
   37     37   
        &self,
   38     38   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   39     39   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   40     40   
        if let Some(ref val) = self.payload {
   41     41   
            ser.write_blob(&RECORDSEVENT_MEMBER_PAYLOAD, val)?;
   42     42   
        }
   43     43   
        Ok(())
   44     44   
    }
   45     45   
}
   46     46   
impl RecordsEvent {
   47     47   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   48         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   49         -
        deserializer: &mut D,
          48  +
    pub fn deserialize(
          49  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   50     50   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   51     51   
        #[allow(unused_variables, unused_mut)]
   52     52   
        let mut builder = Self::builder();
   53     53   
        #[allow(
   54     54   
            unused_variables,
   55     55   
            unreachable_code,
   56     56   
            clippy::single_match,
   57     57   
            clippy::match_single_binding,
   58     58   
            clippy::diverging_sub_expression
   59     59   
        )]
   60         -
        deserializer.read_struct(&RECORDSEVENT_SCHEMA, (), |_, member, deser| {
          60  +
        deserializer.read_struct(&RECORDSEVENT_SCHEMA, &mut |member, deser| {
   61     61   
            match member.member_index() {
   62     62   
                Some(0) => {
   63     63   
                    builder.payload = Some(deser.read_blob(member)?);
   64     64   
                }
   65     65   
                _ => {}
   66     66   
            }
   67     67   
            Ok(())
   68     68   
        })?;
   69     69   
        Ok(builder.build())
   70     70   
    }
   71     71   
}
          72  +
impl RecordsEvent {
          73  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          74  +
    pub fn deserialize_with_response(
          75  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          76  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          77  +
        _status: u16,
          78  +
        _body: &[u8],
          79  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          80  +
        Self::deserialize(deserializer)
          81  +
    }
          82  +
}
   72     83   
impl RecordsEvent {
   73     84   
    /// Creates a new builder-style object to manufacture [`RecordsEvent`](crate::types::RecordsEvent).
   74     85   
    pub fn builder() -> crate::types::builders::RecordsEventBuilder {
   75     86   
        crate::types::builders::RecordsEventBuilder::default()
   76     87   
    }
   77     88   
}
   78     89   
   79     90   
/// A builder for [`RecordsEvent`](crate::types::RecordsEvent).
   80     91   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   81     92   
#[non_exhaustive]

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

@@ -23,23 +186,197 @@
   43     43   
    /// </important>
   44     44   
    pub fn replace_key_with(&self) -> ::std::option::Option<&str> {
   45     45   
        self.replace_key_with.as_deref()
   46     46   
    }
   47     47   
}
   48     48   
static REDIRECT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Redirect", "com.amazonaws.s3", "Redirect");
   50     50   
static REDIRECT_MEMBER_HOST_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Redirect$HostName", "com.amazonaws.s3", "Redirect"),
   52     52   
    ::aws_smithy_schema::ShapeType::String,
   53         -
    "host_name",
          53  +
    "HostName",
   54     54   
    0,
   55     55   
);
   56     56   
static REDIRECT_MEMBER_HTTP_REDIRECT_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Redirect$HttpRedirectCode", "com.amazonaws.s3", "Redirect"),
   58     58   
    ::aws_smithy_schema::ShapeType::String,
   59         -
    "http_redirect_code",
          59  +
    "HttpRedirectCode",
   60     60   
    1,
   61     61   
);
   62     62   
static REDIRECT_MEMBER_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Redirect$Protocol", "com.amazonaws.s3", "Redirect"),
   64     64   
    ::aws_smithy_schema::ShapeType::String,
   65         -
    "protocol",
          65  +
    "Protocol",
   66     66   
    2,
   67     67   
);
   68     68   
static REDIRECT_MEMBER_REPLACE_KEY_PREFIX_WITH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Redirect$ReplaceKeyPrefixWith", "com.amazonaws.s3", "Redirect"),
   70     70   
    ::aws_smithy_schema::ShapeType::String,
   71         -
    "replace_key_prefix_with",
          71  +
    "ReplaceKeyPrefixWith",
   72     72   
    3,
   73     73   
);
   74     74   
static REDIRECT_MEMBER_REPLACE_KEY_WITH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Redirect$ReplaceKeyWith", "com.amazonaws.s3", "Redirect"),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "replace_key_with",
          77  +
    "ReplaceKeyWith",
   78     78   
    4,
   79     79   
);
   80     80   
static REDIRECT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   81     81   
    REDIRECT_SCHEMA_ID,
   82     82   
    ::aws_smithy_schema::ShapeType::Structure,
   83     83   
    &[
   84     84   
        &REDIRECT_MEMBER_HOST_NAME,
   85     85   
        &REDIRECT_MEMBER_HTTP_REDIRECT_CODE,
   86     86   
        &REDIRECT_MEMBER_PROTOCOL,
   87     87   
        &REDIRECT_MEMBER_REPLACE_KEY_PREFIX_WITH,
   88     88   
        &REDIRECT_MEMBER_REPLACE_KEY_WITH,
   89     89   
    ],
   90     90   
);
   91     91   
impl Redirect {
   92     92   
    /// The schema for this shape.
   93     93   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REDIRECT_SCHEMA;
   94     94   
}
   95     95   
impl ::aws_smithy_schema::serde::SerializableStruct for Redirect {
   96     96   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   97     97   
    fn serialize_members(
   98     98   
        &self,
   99     99   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  100    100   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  101    101   
        if let Some(ref val) = self.host_name {
  102    102   
            ser.write_string(&REDIRECT_MEMBER_HOST_NAME, val)?;
  103    103   
        }
  104    104   
        if let Some(ref val) = self.http_redirect_code {
  105    105   
            ser.write_string(&REDIRECT_MEMBER_HTTP_REDIRECT_CODE, val)?;
  106    106   
        }
  107    107   
        if let Some(ref val) = self.protocol {
  108    108   
            ser.write_string(&REDIRECT_MEMBER_PROTOCOL, val.as_str())?;
  109    109   
        }
  110    110   
        if let Some(ref val) = self.replace_key_prefix_with {
  111    111   
            ser.write_string(&REDIRECT_MEMBER_REPLACE_KEY_PREFIX_WITH, val)?;
  112    112   
        }
  113    113   
        if let Some(ref val) = self.replace_key_with {
  114    114   
            ser.write_string(&REDIRECT_MEMBER_REPLACE_KEY_WITH, val)?;
  115    115   
        }
  116    116   
        Ok(())
  117    117   
    }
  118    118   
}
  119    119   
impl Redirect {
  120    120   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  121         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  122         -
        deserializer: &mut D,
         121  +
    pub fn deserialize(
         122  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  123    123   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  124    124   
        #[allow(unused_variables, unused_mut)]
  125    125   
        let mut builder = Self::builder();
  126    126   
        #[allow(
  127    127   
            unused_variables,
  128    128   
            unreachable_code,
  129    129   
            clippy::single_match,
  130    130   
            clippy::match_single_binding,
  131    131   
            clippy::diverging_sub_expression
  132    132   
        )]
  133         -
        deserializer.read_struct(&REDIRECT_SCHEMA, (), |_, member, deser| {
         133  +
        deserializer.read_struct(&REDIRECT_SCHEMA, &mut |member, deser| {
  134    134   
            match member.member_index() {
  135    135   
                Some(0) => {
  136    136   
                    builder.host_name = Some(deser.read_string(member)?);
  137    137   
                }
  138    138   
                Some(1) => {
  139    139   
                    builder.http_redirect_code = Some(deser.read_string(member)?);
  140    140   
                }
  141    141   
                Some(2) => {
  142    142   
                    builder.protocol = Some(crate::types::Protocol::from(deser.read_string(member)?.as_str()));
  143    143   
                }
  144    144   
                Some(3) => {
  145    145   
                    builder.replace_key_prefix_with = Some(deser.read_string(member)?);
  146    146   
                }
  147    147   
                Some(4) => {
  148    148   
                    builder.replace_key_with = Some(deser.read_string(member)?);
  149    149   
                }
  150    150   
                _ => {}
  151    151   
            }
  152    152   
            Ok(())
  153    153   
        })?;
  154    154   
        Ok(builder.build())
  155    155   
    }
  156    156   
}
         157  +
impl Redirect {
         158  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         159  +
    pub fn deserialize_with_response(
         160  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         161  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         162  +
        _status: u16,
         163  +
        _body: &[u8],
         164  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         165  +
        Self::deserialize(deserializer)
         166  +
    }
         167  +
}
  157    168   
impl Redirect {
  158    169   
    /// Creates a new builder-style object to manufacture [`Redirect`](crate::types::Redirect).
  159    170   
    pub fn builder() -> crate::types::builders::RedirectBuilder {
  160    171   
        crate::types::builders::RedirectBuilder::default()
  161    172   
    }
  162    173   
}
  163    174   
  164    175   
/// A builder for [`Redirect`](crate::types::Redirect).
  165    176   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  166    177   
#[non_exhaustive]

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

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

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

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