AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

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

@@ -21,21 +197,208 @@
   41     41   
    /// <p>The checksum type that is used to calculate the object’s checksum value. 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>
   42     42   
    pub fn checksum_type(&self) -> ::std::option::Option<&crate::types::ChecksumType> {
   43     43   
        self.checksum_type.as_ref()
   44     44   
    }
   45     45   
}
   46     46   
static CHECKSUM_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Checksum", "com.amazonaws.s3", "Checksum");
   48     48   
static CHECKSUM_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Checksum$ChecksumCRC32", "com.amazonaws.s3", "Checksum"),
   50     50   
    ::aws_smithy_schema::ShapeType::String,
   51         -
    "checksum_crc32",
          51  +
    "ChecksumCRC32",
   52     52   
    0,
   53     53   
);
   54     54   
static CHECKSUM_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Checksum$ChecksumCRC32C", "com.amazonaws.s3", "Checksum"),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "checksum_crc32_c",
          57  +
    "ChecksumCRC32C",
   58     58   
    1,
   59     59   
);
   60     60   
static CHECKSUM_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Checksum$ChecksumCRC64NVME", "com.amazonaws.s3", "Checksum"),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "checksum_crc64_nvme",
          63  +
    "ChecksumCRC64NVME",
   64     64   
    2,
   65     65   
);
   66     66   
static CHECKSUM_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Checksum$ChecksumSHA1", "com.amazonaws.s3", "Checksum"),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "checksum_sha1",
          69  +
    "ChecksumSHA1",
   70     70   
    3,
   71     71   
);
   72     72   
static CHECKSUM_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Checksum$ChecksumSHA256", "com.amazonaws.s3", "Checksum"),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "checksum_sha256",
          75  +
    "ChecksumSHA256",
   76     76   
    4,
   77     77   
);
   78     78   
static CHECKSUM_MEMBER_CHECKSUM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Checksum$ChecksumType", "com.amazonaws.s3", "Checksum"),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "checksum_type",
          81  +
    "ChecksumType",
   82     82   
    5,
   83     83   
);
   84     84   
static CHECKSUM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   85     85   
    CHECKSUM_SCHEMA_ID,
   86     86   
    ::aws_smithy_schema::ShapeType::Structure,
   87     87   
    &[
   88     88   
        &CHECKSUM_MEMBER_CHECKSUM_CRC32,
   89     89   
        &CHECKSUM_MEMBER_CHECKSUM_CRC32_C,
   90     90   
        &CHECKSUM_MEMBER_CHECKSUM_CRC64_NVME,
   91     91   
        &CHECKSUM_MEMBER_CHECKSUM_SHA1,
   92     92   
        &CHECKSUM_MEMBER_CHECKSUM_SHA256,
   93     93   
        &CHECKSUM_MEMBER_CHECKSUM_TYPE,
   94     94   
    ],
   95     95   
);
   96     96   
impl Checksum {
   97     97   
    /// The schema for this shape.
   98     98   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CHECKSUM_SCHEMA;
   99     99   
}
  100    100   
impl ::aws_smithy_schema::serde::SerializableStruct for Checksum {
  101    101   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  102    102   
    fn serialize_members(
  103    103   
        &self,
  104    104   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  105    105   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  106    106   
        if let Some(ref val) = self.checksum_crc32 {
  107    107   
            ser.write_string(&CHECKSUM_MEMBER_CHECKSUM_CRC32, val)?;
  108    108   
        }
  109    109   
        if let Some(ref val) = self.checksum_crc32_c {
  110    110   
            ser.write_string(&CHECKSUM_MEMBER_CHECKSUM_CRC32_C, val)?;
  111    111   
        }
  112    112   
        if let Some(ref val) = self.checksum_crc64_nvme {
  113    113   
            ser.write_string(&CHECKSUM_MEMBER_CHECKSUM_CRC64_NVME, val)?;
  114    114   
        }
  115    115   
        if let Some(ref val) = self.checksum_sha1 {
  116    116   
            ser.write_string(&CHECKSUM_MEMBER_CHECKSUM_SHA1, val)?;
  117    117   
        }
  118    118   
        if let Some(ref val) = self.checksum_sha256 {
  119    119   
            ser.write_string(&CHECKSUM_MEMBER_CHECKSUM_SHA256, val)?;
  120    120   
        }
  121    121   
        if let Some(ref val) = self.checksum_type {
  122    122   
            ser.write_string(&CHECKSUM_MEMBER_CHECKSUM_TYPE, val.as_str())?;
  123    123   
        }
  124    124   
        Ok(())
  125    125   
    }
  126    126   
}
  127    127   
impl Checksum {
  128    128   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  129         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  130         -
        deserializer: &mut D,
         129  +
    pub fn deserialize(
         130  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  131    131   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  132    132   
        #[allow(unused_variables, unused_mut)]
  133    133   
        let mut builder = Self::builder();
  134    134   
        #[allow(
  135    135   
            unused_variables,
  136    136   
            unreachable_code,
  137    137   
            clippy::single_match,
  138    138   
            clippy::match_single_binding,
  139    139   
            clippy::diverging_sub_expression
  140    140   
        )]
  141         -
        deserializer.read_struct(&CHECKSUM_SCHEMA, (), |_, member, deser| {
         141  +
        deserializer.read_struct(&CHECKSUM_SCHEMA, &mut |member, deser| {
  142    142   
            match member.member_index() {
  143    143   
                Some(0) => {
  144    144   
                    builder.checksum_crc32 = Some(deser.read_string(member)?);
  145    145   
                }
  146    146   
                Some(1) => {
  147    147   
                    builder.checksum_crc32_c = Some(deser.read_string(member)?);
  148    148   
                }
  149    149   
                Some(2) => {
  150    150   
                    builder.checksum_crc64_nvme = Some(deser.read_string(member)?);
  151    151   
                }
  152    152   
                Some(3) => {
  153    153   
                    builder.checksum_sha1 = Some(deser.read_string(member)?);
  154    154   
                }
  155    155   
                Some(4) => {
  156    156   
                    builder.checksum_sha256 = Some(deser.read_string(member)?);
  157    157   
                }
  158    158   
                Some(5) => {
  159    159   
                    builder.checksum_type = Some(crate::types::ChecksumType::from(deser.read_string(member)?.as_str()));
  160    160   
                }
  161    161   
                _ => {}
  162    162   
            }
  163    163   
            Ok(())
  164    164   
        })?;
  165    165   
        Ok(builder.build())
  166    166   
    }
  167    167   
}
         168  +
impl Checksum {
         169  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         170  +
    pub fn deserialize_with_response(
         171  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         172  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         173  +
        _status: u16,
         174  +
        _body: &[u8],
         175  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         176  +
        Self::deserialize(deserializer)
         177  +
    }
         178  +
}
  168    179   
impl Checksum {
  169    180   
    /// Creates a new builder-style object to manufacture [`Checksum`](crate::types::Checksum).
  170    181   
    pub fn builder() -> crate::types::builders::ChecksumBuilder {
  171    182   
        crate::types::builders::ChecksumBuilder::default()
  172    183   
    }
  173    184   
}
  174    185   
  175    186   
/// A builder for [`Checksum`](crate::types::Checksum).
  176    187   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  177    188   
#[non_exhaustive]

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

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

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

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

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

@@ -41,41 +230,241 @@
   61     61   
    /// </note>
   62     62   
    pub fn part_number(&self) -> ::std::option::Option<i32> {
   63     63   
        self.part_number
   64     64   
    }
   65     65   
}
   66     66   
static COMPLETEDPART_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CompletedPart", "com.amazonaws.s3", "CompletedPart");
   68     68   
static COMPLETEDPART_MEMBER_E_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CompletedPart$ETag", "com.amazonaws.s3", "CompletedPart"),
   70     70   
    ::aws_smithy_schema::ShapeType::String,
   71         -
    "e_tag",
          71  +
    "ETag",
   72     72   
    0,
   73     73   
);
   74     74   
static COMPLETEDPART_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CompletedPart$ChecksumCRC32", "com.amazonaws.s3", "CompletedPart"),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "checksum_crc32",
          77  +
    "ChecksumCRC32",
   78     78   
    1,
   79     79   
);
   80     80   
static COMPLETEDPART_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CompletedPart$ChecksumCRC32C", "com.amazonaws.s3", "CompletedPart"),
   82     82   
    ::aws_smithy_schema::ShapeType::String,
   83         -
    "checksum_crc32_c",
          83  +
    "ChecksumCRC32C",
   84     84   
    2,
   85     85   
);
   86     86   
static COMPLETEDPART_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CompletedPart$ChecksumCRC64NVME", "com.amazonaws.s3", "CompletedPart"),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "checksum_crc64_nvme",
          89  +
    "ChecksumCRC64NVME",
   90     90   
    3,
   91     91   
);
   92     92   
static COMPLETEDPART_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CompletedPart$ChecksumSHA1", "com.amazonaws.s3", "CompletedPart"),
   94     94   
    ::aws_smithy_schema::ShapeType::String,
   95         -
    "checksum_sha1",
          95  +
    "ChecksumSHA1",
   96     96   
    4,
   97     97   
);
   98     98   
static COMPLETEDPART_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CompletedPart$ChecksumSHA256", "com.amazonaws.s3", "CompletedPart"),
  100    100   
    ::aws_smithy_schema::ShapeType::String,
  101         -
    "checksum_sha256",
         101  +
    "ChecksumSHA256",
  102    102   
    5,
  103    103   
);
  104    104   
static COMPLETEDPART_MEMBER_PART_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CompletedPart$PartNumber", "com.amazonaws.s3", "CompletedPart"),
  106    106   
    ::aws_smithy_schema::ShapeType::Integer,
  107         -
    "part_number",
         107  +
    "PartNumber",
  108    108   
    6,
  109    109   
);
  110    110   
static COMPLETEDPART_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  111    111   
    COMPLETEDPART_SCHEMA_ID,
  112    112   
    ::aws_smithy_schema::ShapeType::Structure,
  113    113   
    &[
  114    114   
        &COMPLETEDPART_MEMBER_E_TAG,
  115    115   
        &COMPLETEDPART_MEMBER_CHECKSUM_CRC32,
  116    116   
        &COMPLETEDPART_MEMBER_CHECKSUM_CRC32_C,
  117    117   
        &COMPLETEDPART_MEMBER_CHECKSUM_CRC64_NVME,
  118    118   
        &COMPLETEDPART_MEMBER_CHECKSUM_SHA1,
  119    119   
        &COMPLETEDPART_MEMBER_CHECKSUM_SHA256,
  120    120   
        &COMPLETEDPART_MEMBER_PART_NUMBER,
  121    121   
    ],
  122    122   
);
  123    123   
impl CompletedPart {
  124    124   
    /// The schema for this shape.
  125    125   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COMPLETEDPART_SCHEMA;
  126    126   
}
  127    127   
impl ::aws_smithy_schema::serde::SerializableStruct for CompletedPart {
  128    128   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  129    129   
    fn serialize_members(
  130    130   
        &self,
  131    131   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  132    132   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  133    133   
        if let Some(ref val) = self.e_tag {
  134    134   
            ser.write_string(&COMPLETEDPART_MEMBER_E_TAG, val)?;
  135    135   
        }
  136    136   
        if let Some(ref val) = self.checksum_crc32 {
  137    137   
            ser.write_string(&COMPLETEDPART_MEMBER_CHECKSUM_CRC32, val)?;
  138    138   
        }
  139    139   
        if let Some(ref val) = self.checksum_crc32_c {
  140    140   
            ser.write_string(&COMPLETEDPART_MEMBER_CHECKSUM_CRC32_C, val)?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.checksum_crc64_nvme {
  143    143   
            ser.write_string(&COMPLETEDPART_MEMBER_CHECKSUM_CRC64_NVME, val)?;
  144    144   
        }
  145    145   
        if let Some(ref val) = self.checksum_sha1 {
  146    146   
            ser.write_string(&COMPLETEDPART_MEMBER_CHECKSUM_SHA1, val)?;
  147    147   
        }
  148    148   
        if let Some(ref val) = self.checksum_sha256 {
  149    149   
            ser.write_string(&COMPLETEDPART_MEMBER_CHECKSUM_SHA256, val)?;
  150    150   
        }
  151    151   
        if let Some(ref val) = self.part_number {
  152    152   
            ser.write_integer(&COMPLETEDPART_MEMBER_PART_NUMBER, *val)?;
  153    153   
        }
  154    154   
        Ok(())
  155    155   
    }
  156    156   
}
  157    157   
impl CompletedPart {
  158    158   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  159         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  160         -
        deserializer: &mut D,
         159  +
    pub fn deserialize(
         160  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  161    161   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  162    162   
        #[allow(unused_variables, unused_mut)]
  163    163   
        let mut builder = Self::builder();
  164    164   
        #[allow(
  165    165   
            unused_variables,
  166    166   
            unreachable_code,
  167    167   
            clippy::single_match,
  168    168   
            clippy::match_single_binding,
  169    169   
            clippy::diverging_sub_expression
  170    170   
        )]
  171         -
        deserializer.read_struct(&COMPLETEDPART_SCHEMA, (), |_, member, deser| {
         171  +
        deserializer.read_struct(&COMPLETEDPART_SCHEMA, &mut |member, deser| {
  172    172   
            match member.member_index() {
  173    173   
                Some(0) => {
  174    174   
                    builder.e_tag = Some(deser.read_string(member)?);
  175    175   
                }
  176    176   
                Some(1) => {
  177    177   
                    builder.checksum_crc32 = Some(deser.read_string(member)?);
  178    178   
                }
  179    179   
                Some(2) => {
  180    180   
                    builder.checksum_crc32_c = Some(deser.read_string(member)?);
  181    181   
                }
  182    182   
                Some(3) => {
  183    183   
                    builder.checksum_crc64_nvme = Some(deser.read_string(member)?);
  184    184   
                }
  185    185   
                Some(4) => {
  186    186   
                    builder.checksum_sha1 = Some(deser.read_string(member)?);
  187    187   
                }
  188    188   
                Some(5) => {
  189    189   
                    builder.checksum_sha256 = Some(deser.read_string(member)?);
  190    190   
                }
  191    191   
                Some(6) => {
  192    192   
                    builder.part_number = Some(deser.read_integer(member)?);
  193    193   
                }
  194    194   
                _ => {}
  195    195   
            }
  196    196   
            Ok(())
  197    197   
        })?;
  198    198   
        Ok(builder.build())
  199    199   
    }
  200    200   
}
         201  +
impl CompletedPart {
         202  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         203  +
    pub fn deserialize_with_response(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         205  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         206  +
        _status: u16,
         207  +
        _body: &[u8],
         208  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         209  +
        Self::deserialize(deserializer)
         210  +
    }
         211  +
}
  201    212   
impl CompletedPart {
  202    213   
    /// Creates a new builder-style object to manufacture [`CompletedPart`](crate::types::CompletedPart).
  203    214   
    pub fn builder() -> crate::types::builders::CompletedPartBuilder {
  204    215   
        crate::types::builders::CompletedPartBuilder::default()
  205    216   
    }
  206    217   
}
  207    218   
  208    219   
/// A builder for [`CompletedPart`](crate::types::CompletedPart).
  209    220   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  210    221   
#[non_exhaustive]

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

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

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

@@ -33,33 +239,250 @@
   53     53   
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. 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>
   54     54   
    pub fn checksum_sha256(&self) -> ::std::option::Option<&str> {
   55     55   
        self.checksum_sha256.as_deref()
   56     56   
    }
   57     57   
}
   58     58   
static COPYOBJECTRESULT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   59     59   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyObjectResult", "com.amazonaws.s3", "CopyObjectResult");
   60     60   
static COPYOBJECTRESULT_MEMBER_E_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyObjectResult$ETag", "com.amazonaws.s3", "CopyObjectResult"),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "e_tag",
          63  +
    "ETag",
   64     64   
    0,
   65     65   
);
   66     66   
static COPYOBJECTRESULT_MEMBER_LAST_MODIFIED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyObjectResult$LastModified", "com.amazonaws.s3", "CopyObjectResult"),
   68     68   
    ::aws_smithy_schema::ShapeType::Timestamp,
   69         -
    "last_modified",
          69  +
    "LastModified",
   70     70   
    1,
   71     71   
);
   72     72   
static COPYOBJECTRESULT_MEMBER_CHECKSUM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyObjectResult$ChecksumType", "com.amazonaws.s3", "CopyObjectResult"),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "checksum_type",
          75  +
    "ChecksumType",
   76     76   
    2,
   77     77   
);
   78     78   
static COPYOBJECTRESULT_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyObjectResult$ChecksumCRC32", "com.amazonaws.s3", "CopyObjectResult"),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "checksum_crc32",
          81  +
    "ChecksumCRC32",
   82     82   
    3,
   83     83   
);
   84     84   
static COPYOBJECTRESULT_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyObjectResult$ChecksumCRC32C", "com.amazonaws.s3", "CopyObjectResult"),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "checksum_crc32_c",
          87  +
    "ChecksumCRC32C",
   88     88   
    4,
   89     89   
);
   90     90   
static COPYOBJECTRESULT_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.s3#CopyObjectResult$ChecksumCRC64NVME",
   93     93   
        "com.amazonaws.s3",
   94     94   
        "CopyObjectResult",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::String,
   97         -
    "checksum_crc64_nvme",
          97  +
    "ChecksumCRC64NVME",
   98     98   
    5,
   99     99   
);
  100    100   
static COPYOBJECTRESULT_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyObjectResult$ChecksumSHA1", "com.amazonaws.s3", "CopyObjectResult"),
  102    102   
    ::aws_smithy_schema::ShapeType::String,
  103         -
    "checksum_sha1",
         103  +
    "ChecksumSHA1",
  104    104   
    6,
  105    105   
);
  106    106   
static COPYOBJECTRESULT_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyObjectResult$ChecksumSHA256", "com.amazonaws.s3", "CopyObjectResult"),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "checksum_sha256",
         109  +
    "ChecksumSHA256",
  110    110   
    7,
  111    111   
);
  112    112   
static COPYOBJECTRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  113    113   
    COPYOBJECTRESULT_SCHEMA_ID,
  114    114   
    ::aws_smithy_schema::ShapeType::Structure,
  115    115   
    &[
  116    116   
        &COPYOBJECTRESULT_MEMBER_E_TAG,
  117    117   
        &COPYOBJECTRESULT_MEMBER_LAST_MODIFIED,
  118    118   
        &COPYOBJECTRESULT_MEMBER_CHECKSUM_TYPE,
  119    119   
        &COPYOBJECTRESULT_MEMBER_CHECKSUM_CRC32,
  120    120   
        &COPYOBJECTRESULT_MEMBER_CHECKSUM_CRC32_C,
  121    121   
        &COPYOBJECTRESULT_MEMBER_CHECKSUM_CRC64_NVME,
  122    122   
        &COPYOBJECTRESULT_MEMBER_CHECKSUM_SHA1,
  123    123   
        &COPYOBJECTRESULT_MEMBER_CHECKSUM_SHA256,
  124    124   
    ],
  125    125   
);
  126    126   
impl CopyObjectResult {
  127    127   
    /// The schema for this shape.
  128    128   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COPYOBJECTRESULT_SCHEMA;
  129    129   
}
  130    130   
impl ::aws_smithy_schema::serde::SerializableStruct for CopyObjectResult {
  131    131   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  132    132   
    fn serialize_members(
  133    133   
        &self,
  134    134   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  135    135   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  136    136   
        if let Some(ref val) = self.e_tag {
  137    137   
            ser.write_string(&COPYOBJECTRESULT_MEMBER_E_TAG, val)?;
  138    138   
        }
  139    139   
        if let Some(ref val) = self.last_modified {
  140    140   
            ser.write_timestamp(&COPYOBJECTRESULT_MEMBER_LAST_MODIFIED, val)?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.checksum_type {
  143    143   
            ser.write_string(&COPYOBJECTRESULT_MEMBER_CHECKSUM_TYPE, val.as_str())?;
  144    144   
        }
  145    145   
        if let Some(ref val) = self.checksum_crc32 {
  146    146   
            ser.write_string(&COPYOBJECTRESULT_MEMBER_CHECKSUM_CRC32, val)?;
  147    147   
        }
  148    148   
        if let Some(ref val) = self.checksum_crc32_c {
  149    149   
            ser.write_string(&COPYOBJECTRESULT_MEMBER_CHECKSUM_CRC32_C, val)?;
  150    150   
        }
  151    151   
        if let Some(ref val) = self.checksum_crc64_nvme {
  152    152   
            ser.write_string(&COPYOBJECTRESULT_MEMBER_CHECKSUM_CRC64_NVME, val)?;
  153    153   
        }
  154    154   
        if let Some(ref val) = self.checksum_sha1 {
  155    155   
            ser.write_string(&COPYOBJECTRESULT_MEMBER_CHECKSUM_SHA1, val)?;
  156    156   
        }
  157    157   
        if let Some(ref val) = self.checksum_sha256 {
  158    158   
            ser.write_string(&COPYOBJECTRESULT_MEMBER_CHECKSUM_SHA256, val)?;
  159    159   
        }
  160    160   
        Ok(())
  161    161   
    }
  162    162   
}
  163    163   
impl CopyObjectResult {
  164    164   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  165         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  166         -
        deserializer: &mut D,
         165  +
    pub fn deserialize(
         166  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  167    167   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  168    168   
        #[allow(unused_variables, unused_mut)]
  169    169   
        let mut builder = Self::builder();
  170    170   
        #[allow(
  171    171   
            unused_variables,
  172    172   
            unreachable_code,
  173    173   
            clippy::single_match,
  174    174   
            clippy::match_single_binding,
  175    175   
            clippy::diverging_sub_expression
  176    176   
        )]
  177         -
        deserializer.read_struct(&COPYOBJECTRESULT_SCHEMA, (), |_, member, deser| {
         177  +
        deserializer.read_struct(&COPYOBJECTRESULT_SCHEMA, &mut |member, deser| {
  178    178   
            match member.member_index() {
  179    179   
                Some(0) => {
  180    180   
                    builder.e_tag = Some(deser.read_string(member)?);
  181    181   
                }
  182    182   
                Some(1) => {
  183    183   
                    builder.last_modified = Some(deser.read_timestamp(member)?);
  184    184   
                }
  185    185   
                Some(2) => {
  186    186   
                    builder.checksum_type = Some(crate::types::ChecksumType::from(deser.read_string(member)?.as_str()));
  187    187   
                }
  188    188   
                Some(3) => {
  189    189   
                    builder.checksum_crc32 = Some(deser.read_string(member)?);
  190    190   
                }
  191    191   
                Some(4) => {
  192    192   
                    builder.checksum_crc32_c = Some(deser.read_string(member)?);
  193    193   
                }
  194    194   
                Some(5) => {
  195    195   
                    builder.checksum_crc64_nvme = Some(deser.read_string(member)?);
  196    196   
                }
  197    197   
                Some(6) => {
  198    198   
                    builder.checksum_sha1 = Some(deser.read_string(member)?);
  199    199   
                }
  200    200   
                Some(7) => {
  201    201   
                    builder.checksum_sha256 = Some(deser.read_string(member)?);
  202    202   
                }
  203    203   
                _ => {}
  204    204   
            }
  205    205   
            Ok(())
  206    206   
        })?;
  207    207   
        Ok(builder.build())
  208    208   
    }
  209    209   
}
         210  +
impl CopyObjectResult {
         211  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         212  +
    pub fn deserialize_with_response(
         213  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         214  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         215  +
        _status: u16,
         216  +
        _body: &[u8],
         217  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         218  +
        Self::deserialize(deserializer)
         219  +
    }
         220  +
}
  210    221   
impl CopyObjectResult {
  211    222   
    /// Creates a new builder-style object to manufacture [`CopyObjectResult`](crate::types::CopyObjectResult).
  212    223   
    pub fn builder() -> crate::types::builders::CopyObjectResultBuilder {
  213    224   
        crate::types::builders::CopyObjectResultBuilder::default()
  214    225   
    }
  215    226   
}
  216    227   
  217    228   
/// A builder for [`CopyObjectResult`](crate::types::CopyObjectResult).
  218    229   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  219    230   
#[non_exhaustive]

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

@@ -27,27 +216,227 @@
   47     47   
    /// <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent. This header specifies the Base64 encoded, 256-bit <code>SHA256</code> checksum of the part. 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>
   48     48   
    pub fn checksum_sha256(&self) -> ::std::option::Option<&str> {
   49     49   
        self.checksum_sha256.as_deref()
   50     50   
    }
   51     51   
}
   52     52   
static COPYPARTRESULT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   53     53   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult", "com.amazonaws.s3", "CopyPartResult");
   54     54   
static COPYPARTRESULT_MEMBER_E_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$ETag", "com.amazonaws.s3", "CopyPartResult"),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "e_tag",
          57  +
    "ETag",
   58     58   
    0,
   59     59   
);
   60     60   
static COPYPARTRESULT_MEMBER_LAST_MODIFIED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$LastModified", "com.amazonaws.s3", "CopyPartResult"),
   62     62   
    ::aws_smithy_schema::ShapeType::Timestamp,
   63         -
    "last_modified",
          63  +
    "LastModified",
   64     64   
    1,
   65     65   
);
   66     66   
static COPYPARTRESULT_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$ChecksumCRC32", "com.amazonaws.s3", "CopyPartResult"),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "checksum_crc32",
          69  +
    "ChecksumCRC32",
   70     70   
    2,
   71     71   
);
   72     72   
static COPYPARTRESULT_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$ChecksumCRC32C", "com.amazonaws.s3", "CopyPartResult"),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "checksum_crc32_c",
          75  +
    "ChecksumCRC32C",
   76     76   
    3,
   77     77   
);
   78     78   
static COPYPARTRESULT_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$ChecksumCRC64NVME", "com.amazonaws.s3", "CopyPartResult"),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "checksum_crc64_nvme",
          81  +
    "ChecksumCRC64NVME",
   82     82   
    4,
   83     83   
);
   84     84   
static COPYPARTRESULT_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$ChecksumSHA1", "com.amazonaws.s3", "CopyPartResult"),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "checksum_sha1",
          87  +
    "ChecksumSHA1",
   88     88   
    5,
   89     89   
);
   90     90   
static COPYPARTRESULT_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CopyPartResult$ChecksumSHA256", "com.amazonaws.s3", "CopyPartResult"),
   92     92   
    ::aws_smithy_schema::ShapeType::String,
   93         -
    "checksum_sha256",
          93  +
    "ChecksumSHA256",
   94     94   
    6,
   95     95   
);
   96     96   
static COPYPARTRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   97     97   
    COPYPARTRESULT_SCHEMA_ID,
   98     98   
    ::aws_smithy_schema::ShapeType::Structure,
   99     99   
    &[
  100    100   
        &COPYPARTRESULT_MEMBER_E_TAG,
  101    101   
        &COPYPARTRESULT_MEMBER_LAST_MODIFIED,
  102    102   
        &COPYPARTRESULT_MEMBER_CHECKSUM_CRC32,
  103    103   
        &COPYPARTRESULT_MEMBER_CHECKSUM_CRC32_C,
  104    104   
        &COPYPARTRESULT_MEMBER_CHECKSUM_CRC64_NVME,
  105    105   
        &COPYPARTRESULT_MEMBER_CHECKSUM_SHA1,
  106    106   
        &COPYPARTRESULT_MEMBER_CHECKSUM_SHA256,
  107    107   
    ],
  108    108   
);
  109    109   
impl CopyPartResult {
  110    110   
    /// The schema for this shape.
  111    111   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COPYPARTRESULT_SCHEMA;
  112    112   
}
  113    113   
impl ::aws_smithy_schema::serde::SerializableStruct for CopyPartResult {
  114    114   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  115    115   
    fn serialize_members(
  116    116   
        &self,
  117    117   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  118    118   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  119    119   
        if let Some(ref val) = self.e_tag {
  120    120   
            ser.write_string(&COPYPARTRESULT_MEMBER_E_TAG, val)?;
  121    121   
        }
  122    122   
        if let Some(ref val) = self.last_modified {
  123    123   
            ser.write_timestamp(&COPYPARTRESULT_MEMBER_LAST_MODIFIED, val)?;
  124    124   
        }
  125    125   
        if let Some(ref val) = self.checksum_crc32 {
  126    126   
            ser.write_string(&COPYPARTRESULT_MEMBER_CHECKSUM_CRC32, val)?;
  127    127   
        }
  128    128   
        if let Some(ref val) = self.checksum_crc32_c {
  129    129   
            ser.write_string(&COPYPARTRESULT_MEMBER_CHECKSUM_CRC32_C, val)?;
  130    130   
        }
  131    131   
        if let Some(ref val) = self.checksum_crc64_nvme {
  132    132   
            ser.write_string(&COPYPARTRESULT_MEMBER_CHECKSUM_CRC64_NVME, val)?;
  133    133   
        }
  134    134   
        if let Some(ref val) = self.checksum_sha1 {
  135    135   
            ser.write_string(&COPYPARTRESULT_MEMBER_CHECKSUM_SHA1, val)?;
  136    136   
        }
  137    137   
        if let Some(ref val) = self.checksum_sha256 {
  138    138   
            ser.write_string(&COPYPARTRESULT_MEMBER_CHECKSUM_SHA256, val)?;
  139    139   
        }
  140    140   
        Ok(())
  141    141   
    }
  142    142   
}
  143    143   
impl CopyPartResult {
  144    144   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  145         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  146         -
        deserializer: &mut D,
         145  +
    pub fn deserialize(
         146  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  147    147   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  148    148   
        #[allow(unused_variables, unused_mut)]
  149    149   
        let mut builder = Self::builder();
  150    150   
        #[allow(
  151    151   
            unused_variables,
  152    152   
            unreachable_code,
  153    153   
            clippy::single_match,
  154    154   
            clippy::match_single_binding,
  155    155   
            clippy::diverging_sub_expression
  156    156   
        )]
  157         -
        deserializer.read_struct(&COPYPARTRESULT_SCHEMA, (), |_, member, deser| {
         157  +
        deserializer.read_struct(&COPYPARTRESULT_SCHEMA, &mut |member, deser| {
  158    158   
            match member.member_index() {
  159    159   
                Some(0) => {
  160    160   
                    builder.e_tag = Some(deser.read_string(member)?);
  161    161   
                }
  162    162   
                Some(1) => {
  163    163   
                    builder.last_modified = Some(deser.read_timestamp(member)?);
  164    164   
                }
  165    165   
                Some(2) => {
  166    166   
                    builder.checksum_crc32 = Some(deser.read_string(member)?);
  167    167   
                }
  168    168   
                Some(3) => {
  169    169   
                    builder.checksum_crc32_c = Some(deser.read_string(member)?);
  170    170   
                }
  171    171   
                Some(4) => {
  172    172   
                    builder.checksum_crc64_nvme = Some(deser.read_string(member)?);
  173    173   
                }
  174    174   
                Some(5) => {
  175    175   
                    builder.checksum_sha1 = Some(deser.read_string(member)?);
  176    176   
                }
  177    177   
                Some(6) => {
  178    178   
                    builder.checksum_sha256 = Some(deser.read_string(member)?);
  179    179   
                }
  180    180   
                _ => {}
  181    181   
            }
  182    182   
            Ok(())
  183    183   
        })?;
  184    184   
        Ok(builder.build())
  185    185   
    }
  186    186   
}
         187  +
impl CopyPartResult {
         188  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         189  +
    pub fn deserialize_with_response(
         190  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         191  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         192  +
        _status: u16,
         193  +
        _body: &[u8],
         194  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         195  +
        Self::deserialize(deserializer)
         196  +
    }
         197  +
}
  187    198   
impl CopyPartResult {
  188    199   
    /// Creates a new builder-style object to manufacture [`CopyPartResult`](crate::types::CopyPartResult).
  189    200   
    pub fn builder() -> crate::types::builders::CopyPartResultBuilder {
  190    201   
        crate::types::builders::CopyPartResultBuilder::default()
  191    202   
    }
  192    203   
}
  193    204   
  194    205   
/// A builder for [`CopyPartResult`](crate::types::CopyPartResult).
  195    206   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  196    207   
#[non_exhaustive]

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

@@ -1,1 +125,134 @@
   12     12   
    pub fn cors_rules(&self) -> &[crate::types::CorsRule] {
   13     13   
        use std::ops::Deref;
   14     14   
        self.cors_rules.deref()
   15     15   
    }
   16     16   
}
   17     17   
static CORSCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   18     18   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSConfiguration", "com.amazonaws.s3", "CORSConfiguration");
   19     19   
static CORSCONFIGURATION_MEMBER_CORS_RULES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   20     20   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSConfiguration$CORSRules", "com.amazonaws.s3", "CORSConfiguration"),
   21     21   
    ::aws_smithy_schema::ShapeType::List,
   22         -
    "cors_rules",
          22  +
    "CORSRules",
   23     23   
    0,
   24     24   
)
   25     25   
.with_xml_name("CORSRule")
   26     26   
.with_xml_flattened();
   27     27   
static CORSCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   28     28   
    CORSCONFIGURATION_SCHEMA_ID,
   29     29   
    ::aws_smithy_schema::ShapeType::Structure,
   30     30   
    &[&CORSCONFIGURATION_MEMBER_CORS_RULES],
   31     31   
);
   32     32   
impl CorsConfiguration {
   33     33   
    /// The schema for this shape.
   34     34   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CORSCONFIGURATION_SCHEMA;
   35     35   
}
   36     36   
impl ::aws_smithy_schema::serde::SerializableStruct for CorsConfiguration {
   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.cors_rules;
   44     44   
   45     45   
            ser.write_list(
   46     46   
                &CORSCONFIGURATION_MEMBER_CORS_RULES,
   47     47   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   48     48   
                    for item in val {
   49     49   
                        ser.write_struct(crate::types::CorsRule::SCHEMA, item)?;
   50     50   
                    }
   51     51   
                    Ok(())
   52     52   
                },
   53     53   
            )?;
   54     54   
        }
   55     55   
        Ok(())
   56     56   
    }
   57     57   
}
   58     58   
impl CorsConfiguration {
   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(&CORSCONFIGURATION_SCHEMA, (), |_, member, deser| {
          72  +
        deserializer.read_struct(&CORSCONFIGURATION_SCHEMA, &mut |member, deser| {
   73     73   
            match member.member_index() {
   74     74   
                Some(0) => {
   75     75   
                    builder.cors_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::CorsRule::deserialize(deser)?);
   83         -
                            Ok(list)
   84         -
                        })?
          76  +
                        let mut container = Vec::new();
          77  +
                        deser.read_list(member, &mut |deser| {
          78  +
                            container.push(crate::types::CorsRule::deserialize(deser)?);
          79  +
                            Ok(())
          80  +
                        })?;
          81  +
                        container
   85     82   
                    });
   86     83   
                }
   87     84   
                _ => {}
   88     85   
            }
   89     86   
            Ok(())
   90     87   
        })?;
          88  +
        builder.cors_rules = builder.cors_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 CorsConfiguration {
          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 CorsConfiguration {
   97    106   
    /// Creates a new builder-style object to manufacture [`CorsConfiguration`](crate::types::CorsConfiguration).
   98    107   
    pub fn builder() -> crate::types::builders::CorsConfigurationBuilder {
   99    108   
        crate::types::builders::CorsConfigurationBuilder::default()
  100    109   
    }
  101    110   
}
  102    111   
  103    112   
/// A builder for [`CorsConfiguration`](crate::types::CorsConfiguration).
  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/_cors_rule.rs

@@ -27,27 +125,125 @@
   47     47   
    /// <p>The time in seconds that your browser is to cache the preflight response for the specified resource.</p>
   48     48   
    pub fn max_age_seconds(&self) -> ::std::option::Option<i32> {
   49     49   
        self.max_age_seconds
   50     50   
    }
   51     51   
}
   52     52   
static CORSRULE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   53     53   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule", "com.amazonaws.s3", "CORSRule");
   54     54   
static CORSRULE_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule$ID", "com.amazonaws.s3", "CORSRule"),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "id",
          57  +
    "ID",
   58     58   
    0,
   59     59   
);
   60     60   
static CORSRULE_MEMBER_ALLOWED_HEADERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule$AllowedHeaders", "com.amazonaws.s3", "CORSRule"),
   62     62   
    ::aws_smithy_schema::ShapeType::List,
   63         -
    "allowed_headers",
          63  +
    "AllowedHeaders",
   64     64   
    1,
   65     65   
)
   66     66   
.with_xml_name("AllowedHeader")
   67     67   
.with_xml_flattened();
   68     68   
static CORSRULE_MEMBER_ALLOWED_METHODS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule$AllowedMethods", "com.amazonaws.s3", "CORSRule"),
   70     70   
    ::aws_smithy_schema::ShapeType::List,
   71         -
    "allowed_methods",
          71  +
    "AllowedMethods",
   72     72   
    2,
   73     73   
)
   74     74   
.with_xml_name("AllowedMethod")
   75     75   
.with_xml_flattened();
   76     76   
static CORSRULE_MEMBER_ALLOWED_ORIGINS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   77     77   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule$AllowedOrigins", "com.amazonaws.s3", "CORSRule"),
   78     78   
    ::aws_smithy_schema::ShapeType::List,
   79         -
    "allowed_origins",
          79  +
    "AllowedOrigins",
   80     80   
    3,
   81     81   
)
   82     82   
.with_xml_name("AllowedOrigin")
   83     83   
.with_xml_flattened();
   84     84   
static CORSRULE_MEMBER_EXPOSE_HEADERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule$ExposeHeaders", "com.amazonaws.s3", "CORSRule"),
   86     86   
    ::aws_smithy_schema::ShapeType::List,
   87         -
    "expose_headers",
          87  +
    "ExposeHeaders",
   88     88   
    4,
   89     89   
)
   90     90   
.with_xml_name("ExposeHeader")
   91     91   
.with_xml_flattened();
   92     92   
static CORSRULE_MEMBER_MAX_AGE_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CORSRule$MaxAgeSeconds", "com.amazonaws.s3", "CORSRule"),
   94     94   
    ::aws_smithy_schema::ShapeType::Integer,
   95         -
    "max_age_seconds",
          95  +
    "MaxAgeSeconds",
   96     96   
    5,
   97     97   
);
   98     98   
static CORSRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   99     99   
    CORSRULE_SCHEMA_ID,
  100    100   
    ::aws_smithy_schema::ShapeType::Structure,
  101    101   
    &[
  102    102   
        &CORSRULE_MEMBER_ID,
  103    103   
        &CORSRULE_MEMBER_ALLOWED_HEADERS,
  104    104   
        &CORSRULE_MEMBER_ALLOWED_METHODS,
  105    105   
        &CORSRULE_MEMBER_ALLOWED_ORIGINS,
@@ -149,149 +289,262 @@
  169    169   
            )?;
  170    170   
        }
  171    171   
        if let Some(ref val) = self.max_age_seconds {
  172    172   
            ser.write_integer(&CORSRULE_MEMBER_MAX_AGE_SECONDS, *val)?;
  173    173   
        }
  174    174   
        Ok(())
  175    175   
    }
  176    176   
}
  177    177   
impl CorsRule {
  178    178   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  179         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  180         -
        deserializer: &mut D,
         179  +
    pub fn deserialize(
         180  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  181    181   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  182    182   
        #[allow(unused_variables, unused_mut)]
  183    183   
        let mut builder = Self::builder();
  184    184   
        #[allow(
  185    185   
            unused_variables,
  186    186   
            unreachable_code,
  187    187   
            clippy::single_match,
  188    188   
            clippy::match_single_binding,
  189    189   
            clippy::diverging_sub_expression
  190    190   
        )]
  191         -
        deserializer.read_struct(&CORSRULE_SCHEMA, (), |_, member, deser| {
         191  +
        deserializer.read_struct(&CORSRULE_SCHEMA, &mut |member, deser| {
  192    192   
            match member.member_index() {
  193    193   
                Some(0) => {
  194    194   
                    builder.id = Some(deser.read_string(member)?);
  195    195   
                }
  196    196   
                Some(1) => {
  197         -
                    builder.allowed_headers = Some({
  198         -
                        let container = if let Some(cap) = deser.container_size() {
  199         -
                            Vec::with_capacity(cap)
  200         -
                        } else {
  201         -
                            Vec::new()
  202         -
                        };
  203         -
                        deser.read_list(member, container, |mut list, deser| {
  204         -
                            list.push(deser.read_string(member)?);
  205         -
                            Ok(list)
  206         -
                        })?
  207         -
                    });
         197  +
                    builder.allowed_headers = Some(deser.read_string_list(member)?);
  208    198   
                }
  209    199   
                Some(2) => {
  210         -
                    builder.allowed_methods = Some({
  211         -
                        let container = if let Some(cap) = deser.container_size() {
  212         -
                            Vec::with_capacity(cap)
  213         -
                        } else {
  214         -
                            Vec::new()
  215         -
                        };
  216         -
                        deser.read_list(member, container, |mut list, deser| {
  217         -
                            list.push(deser.read_string(member)?);
  218         -
                            Ok(list)
  219         -
                        })?
  220         -
                    });
         200  +
                    builder.allowed_methods = Some(deser.read_string_list(member)?);
  221    201   
                }
  222    202   
                Some(3) => {
  223         -
                    builder.allowed_origins = Some({
  224         -
                        let container = if let Some(cap) = deser.container_size() {
  225         -
                            Vec::with_capacity(cap)
  226         -
                        } else {
  227         -
                            Vec::new()
  228         -
                        };
  229         -
                        deser.read_list(member, container, |mut list, deser| {
  230         -
                            list.push(deser.read_string(member)?);
  231         -
                            Ok(list)
  232         -
                        })?
  233         -
                    });
         203  +
                    builder.allowed_origins = Some(deser.read_string_list(member)?);
  234    204   
                }
  235    205   
                Some(4) => {
  236         -
                    builder.expose_headers = Some({
  237         -
                        let container = if let Some(cap) = deser.container_size() {
  238         -
                            Vec::with_capacity(cap)
  239         -
                        } else {
  240         -
                            Vec::new()
  241         -
                        };
  242         -
                        deser.read_list(member, container, |mut list, deser| {
  243         -
                            list.push(deser.read_string(member)?);
  244         -
                            Ok(list)
  245         -
                        })?
  246         -
                    });
         206  +
                    builder.expose_headers = Some(deser.read_string_list(member)?);
  247    207   
                }
  248    208   
                Some(5) => {
  249    209   
                    builder.max_age_seconds = Some(deser.read_integer(member)?);
  250    210   
                }
  251    211   
                _ => {}
  252    212   
            }
  253    213   
            Ok(())
  254    214   
        })?;
         215  +
        builder.allowed_methods = builder.allowed_methods.or(Some(Vec::new()));
         216  +
        builder.allowed_origins = builder.allowed_origins.or(Some(Vec::new()));
  255    217   
        builder
  256    218   
            .build()
  257    219   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  258    220   
    }
  259    221   
}
         222  +
impl CorsRule {
         223  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         224  +
    pub fn deserialize_with_response(
         225  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         226  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         227  +
        _status: u16,
         228  +
        _body: &[u8],
         229  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         230  +
        Self::deserialize(deserializer)
         231  +
    }
         232  +
}
  260    233   
impl CorsRule {
  261    234   
    /// Creates a new builder-style object to manufacture [`CorsRule`](crate::types::CorsRule).
  262    235   
    pub fn builder() -> crate::types::builders::CorsRuleBuilder {
  263    236   
        crate::types::builders::CorsRuleBuilder::default()
  264    237   
    }
  265    238   
}
  266    239   
  267    240   
/// A builder for [`CorsRule`](crate::types::CorsRule).
  268    241   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  269    242   
#[non_exhaustive]

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

@@ -40,40 +220,228 @@
   60     60   
    "com.amazonaws.s3",
   61     61   
    "CreateBucketConfiguration",
   62     62   
);
   63     63   
static CREATEBUCKETCONFIGURATION_MEMBER_LOCATION_CONSTRAINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.s3#CreateBucketConfiguration$LocationConstraint",
   66     66   
        "com.amazonaws.s3",
   67     67   
        "CreateBucketConfiguration",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "location_constraint",
          70  +
    "LocationConstraint",
   71     71   
    0,
   72     72   
);
   73     73   
static CREATEBUCKETCONFIGURATION_MEMBER_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.s3#CreateBucketConfiguration$Location",
   76     76   
        "com.amazonaws.s3",
   77     77   
        "CreateBucketConfiguration",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::Structure,
   80         -
    "location",
          80  +
    "Location",
   81     81   
    1,
   82     82   
);
   83     83   
static CREATEBUCKETCONFIGURATION_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.s3#CreateBucketConfiguration$Bucket",
   86     86   
        "com.amazonaws.s3",
   87     87   
        "CreateBucketConfiguration",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::Structure,
   90         -
    "bucket",
          90  +
    "Bucket",
   91     91   
    2,
   92     92   
);
   93     93   
static CREATEBUCKETCONFIGURATION_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.s3#CreateBucketConfiguration$Tags",
   96     96   
        "com.amazonaws.s3",
   97     97   
        "CreateBucketConfiguration",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::List,
  100         -
    "tags",
         100  +
    "Tags",
  101    101   
    3,
  102    102   
);
  103    103   
static CREATEBUCKETCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  104    104   
    CREATEBUCKETCONFIGURATION_SCHEMA_ID,
  105    105   
    ::aws_smithy_schema::ShapeType::Structure,
  106    106   
    &[
  107    107   
        &CREATEBUCKETCONFIGURATION_MEMBER_LOCATION_CONSTRAINT,
  108    108   
        &CREATEBUCKETCONFIGURATION_MEMBER_LOCATION,
  109    109   
        &CREATEBUCKETCONFIGURATION_MEMBER_BUCKET,
  110    110   
        &CREATEBUCKETCONFIGURATION_MEMBER_TAGS,
  111    111   
    ],
  112    112   
);
  113    113   
impl CreateBucketConfiguration {
  114    114   
    /// The schema for this shape.
  115    115   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEBUCKETCONFIGURATION_SCHEMA;
  116    116   
}
  117    117   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateBucketConfiguration {
  118    118   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  119    119   
    fn serialize_members(
  120    120   
        &self,
  121    121   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  122    122   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  123    123   
        if let Some(ref val) = self.location_constraint {
  124    124   
            ser.write_string(&CREATEBUCKETCONFIGURATION_MEMBER_LOCATION_CONSTRAINT, val.as_str())?;
  125    125   
        }
  126    126   
        if let Some(ref val) = self.location {
  127    127   
            ser.write_struct(&CREATEBUCKETCONFIGURATION_MEMBER_LOCATION, val)?;
  128    128   
        }
  129    129   
        if let Some(ref val) = self.bucket {
  130    130   
            ser.write_struct(&CREATEBUCKETCONFIGURATION_MEMBER_BUCKET, val)?;
  131    131   
        }
  132    132   
        if let Some(ref val) = self.tags {
  133    133   
            ser.write_list(
  134    134   
                &CREATEBUCKETCONFIGURATION_MEMBER_TAGS,
  135    135   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  136    136   
                    for item in val {
  137    137   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  138    138   
                    }
  139    139   
                    Ok(())
  140    140   
                },
  141    141   
            )?;
  142    142   
        }
  143    143   
        Ok(())
  144    144   
    }
  145    145   
}
  146    146   
impl CreateBucketConfiguration {
  147    147   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  148         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  149         -
        deserializer: &mut D,
         148  +
    pub fn deserialize(
         149  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  150    150   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  151    151   
        #[allow(unused_variables, unused_mut)]
  152    152   
        let mut builder = Self::builder();
  153    153   
        #[allow(
  154    154   
            unused_variables,
  155    155   
            unreachable_code,
  156    156   
            clippy::single_match,
  157    157   
            clippy::match_single_binding,
  158    158   
            clippy::diverging_sub_expression
  159    159   
        )]
  160         -
        deserializer.read_struct(&CREATEBUCKETCONFIGURATION_SCHEMA, (), |_, member, deser| {
         160  +
        deserializer.read_struct(&CREATEBUCKETCONFIGURATION_SCHEMA, &mut |member, deser| {
  161    161   
            match member.member_index() {
  162    162   
                Some(0) => {
  163    163   
                    builder.location_constraint = Some(crate::types::BucketLocationConstraint::from(deser.read_string(member)?.as_str()));
  164    164   
                }
  165    165   
                Some(1) => {
  166    166   
                    builder.location = Some(crate::types::LocationInfo::deserialize(deser)?);
  167    167   
                }
  168    168   
                Some(2) => {
  169    169   
                    builder.bucket = Some(crate::types::BucketInfo::deserialize(deser)?);
  170    170   
                }
  171    171   
                Some(3) => {
  172    172   
                    builder.tags = Some({
  173         -
                        let container = if let Some(cap) = deser.container_size() {
  174         -
                            Vec::with_capacity(cap)
  175         -
                        } else {
  176         -
                            Vec::new()
  177         -
                        };
  178         -
                        deser.read_list(member, container, |mut list, deser| {
  179         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  180         -
                            Ok(list)
  181         -
                        })?
         173  +
                        let mut container = Vec::new();
         174  +
                        deser.read_list(member, &mut |deser| {
         175  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         176  +
                            Ok(())
         177  +
                        })?;
         178  +
                        container
  182    179   
                    });
  183    180   
                }
  184    181   
                _ => {}
  185    182   
            }
  186    183   
            Ok(())
  187    184   
        })?;
  188    185   
        Ok(builder.build())
  189    186   
    }
  190    187   
}
         188  +
impl CreateBucketConfiguration {
         189  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         190  +
    pub fn deserialize_with_response(
         191  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         192  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         193  +
        _status: u16,
         194  +
        _body: &[u8],
         195  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         196  +
        Self::deserialize(deserializer)
         197  +
    }
         198  +
}
  191    199   
impl CreateBucketConfiguration {
  192    200   
    /// Creates a new builder-style object to manufacture [`CreateBucketConfiguration`](crate::types::CreateBucketConfiguration).
  193    201   
    pub fn builder() -> crate::types::builders::CreateBucketConfigurationBuilder {
  194    202   
        crate::types::builders::CreateBucketConfigurationBuilder::default()
  195    203   
    }
  196    204   
}
  197    205   
  198    206   
/// A builder for [`CreateBucketConfiguration`](crate::types::CreateBucketConfiguration).
  199    207   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  200    208   
#[non_exhaustive]

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

@@ -51,51 +240,251 @@
   71     71   
    /// <p>Specifies that CSV field values may contain quoted record delimiters and such records should be allowed. Default value is FALSE. Setting this value to TRUE may lower performance.</p>
   72     72   
    pub fn allow_quoted_record_delimiter(&self) -> ::std::option::Option<bool> {
   73     73   
        self.allow_quoted_record_delimiter
   74     74   
    }
   75     75   
}
   76     76   
static CSVINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   77     77   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput", "com.amazonaws.s3", "CSVInput");
   78     78   
static CSVINPUT_MEMBER_FILE_HEADER_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$FileHeaderInfo", "com.amazonaws.s3", "CSVInput"),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "file_header_info",
          81  +
    "FileHeaderInfo",
   82     82   
    0,
   83     83   
);
   84     84   
static CSVINPUT_MEMBER_COMMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$Comments", "com.amazonaws.s3", "CSVInput"),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "comments",
          87  +
    "Comments",
   88     88   
    1,
   89     89   
);
   90     90   
static CSVINPUT_MEMBER_QUOTE_ESCAPE_CHARACTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$QuoteEscapeCharacter", "com.amazonaws.s3", "CSVInput"),
   92     92   
    ::aws_smithy_schema::ShapeType::String,
   93         -
    "quote_escape_character",
          93  +
    "QuoteEscapeCharacter",
   94     94   
    2,
   95     95   
);
   96     96   
static CSVINPUT_MEMBER_RECORD_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$RecordDelimiter", "com.amazonaws.s3", "CSVInput"),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "record_delimiter",
          99  +
    "RecordDelimiter",
  100    100   
    3,
  101    101   
);
  102    102   
static CSVINPUT_MEMBER_FIELD_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$FieldDelimiter", "com.amazonaws.s3", "CSVInput"),
  104    104   
    ::aws_smithy_schema::ShapeType::String,
  105         -
    "field_delimiter",
         105  +
    "FieldDelimiter",
  106    106   
    4,
  107    107   
);
  108    108   
static CSVINPUT_MEMBER_QUOTE_CHARACTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$QuoteCharacter", "com.amazonaws.s3", "CSVInput"),
  110    110   
    ::aws_smithy_schema::ShapeType::String,
  111         -
    "quote_character",
         111  +
    "QuoteCharacter",
  112    112   
    5,
  113    113   
);
  114    114   
static CSVINPUT_MEMBER_ALLOW_QUOTED_RECORD_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVInput$AllowQuotedRecordDelimiter", "com.amazonaws.s3", "CSVInput"),
  116    116   
    ::aws_smithy_schema::ShapeType::Boolean,
  117         -
    "allow_quoted_record_delimiter",
         117  +
    "AllowQuotedRecordDelimiter",
  118    118   
    6,
  119    119   
);
  120    120   
static CSVINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  121    121   
    CSVINPUT_SCHEMA_ID,
  122    122   
    ::aws_smithy_schema::ShapeType::Structure,
  123    123   
    &[
  124    124   
        &CSVINPUT_MEMBER_FILE_HEADER_INFO,
  125    125   
        &CSVINPUT_MEMBER_COMMENTS,
  126    126   
        &CSVINPUT_MEMBER_QUOTE_ESCAPE_CHARACTER,
  127    127   
        &CSVINPUT_MEMBER_RECORD_DELIMITER,
  128    128   
        &CSVINPUT_MEMBER_FIELD_DELIMITER,
  129    129   
        &CSVINPUT_MEMBER_QUOTE_CHARACTER,
  130    130   
        &CSVINPUT_MEMBER_ALLOW_QUOTED_RECORD_DELIMITER,
  131    131   
    ],
  132    132   
);
  133    133   
impl CsvInput {
  134    134   
    /// The schema for this shape.
  135    135   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CSVINPUT_SCHEMA;
  136    136   
}
  137    137   
impl ::aws_smithy_schema::serde::SerializableStruct for CsvInput {
  138    138   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  139    139   
    fn serialize_members(
  140    140   
        &self,
  141    141   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  142    142   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  143    143   
        if let Some(ref val) = self.file_header_info {
  144    144   
            ser.write_string(&CSVINPUT_MEMBER_FILE_HEADER_INFO, val.as_str())?;
  145    145   
        }
  146    146   
        if let Some(ref val) = self.comments {
  147    147   
            ser.write_string(&CSVINPUT_MEMBER_COMMENTS, val)?;
  148    148   
        }
  149    149   
        if let Some(ref val) = self.quote_escape_character {
  150    150   
            ser.write_string(&CSVINPUT_MEMBER_QUOTE_ESCAPE_CHARACTER, val)?;
  151    151   
        }
  152    152   
        if let Some(ref val) = self.record_delimiter {
  153    153   
            ser.write_string(&CSVINPUT_MEMBER_RECORD_DELIMITER, val)?;
  154    154   
        }
  155    155   
        if let Some(ref val) = self.field_delimiter {
  156    156   
            ser.write_string(&CSVINPUT_MEMBER_FIELD_DELIMITER, val)?;
  157    157   
        }
  158    158   
        if let Some(ref val) = self.quote_character {
  159    159   
            ser.write_string(&CSVINPUT_MEMBER_QUOTE_CHARACTER, val)?;
  160    160   
        }
  161    161   
        if let Some(ref val) = self.allow_quoted_record_delimiter {
  162    162   
            ser.write_boolean(&CSVINPUT_MEMBER_ALLOW_QUOTED_RECORD_DELIMITER, *val)?;
  163    163   
        }
  164    164   
        Ok(())
  165    165   
    }
  166    166   
}
  167    167   
impl CsvInput {
  168    168   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  169         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  170         -
        deserializer: &mut D,
         169  +
    pub fn deserialize(
         170  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  171    171   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  172    172   
        #[allow(unused_variables, unused_mut)]
  173    173   
        let mut builder = Self::builder();
  174    174   
        #[allow(
  175    175   
            unused_variables,
  176    176   
            unreachable_code,
  177    177   
            clippy::single_match,
  178    178   
            clippy::match_single_binding,
  179    179   
            clippy::diverging_sub_expression
  180    180   
        )]
  181         -
        deserializer.read_struct(&CSVINPUT_SCHEMA, (), |_, member, deser| {
         181  +
        deserializer.read_struct(&CSVINPUT_SCHEMA, &mut |member, deser| {
  182    182   
            match member.member_index() {
  183    183   
                Some(0) => {
  184    184   
                    builder.file_header_info = Some(crate::types::FileHeaderInfo::from(deser.read_string(member)?.as_str()));
  185    185   
                }
  186    186   
                Some(1) => {
  187    187   
                    builder.comments = Some(deser.read_string(member)?);
  188    188   
                }
  189    189   
                Some(2) => {
  190    190   
                    builder.quote_escape_character = Some(deser.read_string(member)?);
  191    191   
                }
  192    192   
                Some(3) => {
  193    193   
                    builder.record_delimiter = Some(deser.read_string(member)?);
  194    194   
                }
  195    195   
                Some(4) => {
  196    196   
                    builder.field_delimiter = Some(deser.read_string(member)?);
  197    197   
                }
  198    198   
                Some(5) => {
  199    199   
                    builder.quote_character = Some(deser.read_string(member)?);
  200    200   
                }
  201    201   
                Some(6) => {
  202    202   
                    builder.allow_quoted_record_delimiter = Some(deser.read_boolean(member)?);
  203    203   
                }
  204    204   
                _ => {}
  205    205   
            }
  206    206   
            Ok(())
  207    207   
        })?;
  208    208   
        Ok(builder.build())
  209    209   
    }
  210    210   
}
         211  +
impl CsvInput {
         212  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         213  +
    pub fn deserialize_with_response(
         214  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         215  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         216  +
        _status: u16,
         217  +
        _body: &[u8],
         218  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         219  +
        Self::deserialize(deserializer)
         220  +
    }
         221  +
}
  211    222   
impl CsvInput {
  212    223   
    /// Creates a new builder-style object to manufacture [`CsvInput`](crate::types::CsvInput).
  213    224   
    pub fn builder() -> crate::types::builders::CsvInputBuilder {
  214    225   
        crate::types::builders::CsvInputBuilder::default()
  215    226   
    }
  216    227   
}
  217    228   
  218    229   
/// A builder for [`CsvInput`](crate::types::CsvInput).
  219    230   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  220    231   
#[non_exhaustive]

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

@@ -27,27 +190,201 @@
   47     47   
    /// <p>A single character used for escaping when the field delimiter is part of the value. For example, if the value is <code>a, b</code>, Amazon S3 wraps this field value in quotation marks, as follows: <code>" a , b "</code>.</p>
   48     48   
    pub fn quote_character(&self) -> ::std::option::Option<&str> {
   49     49   
        self.quote_character.as_deref()
   50     50   
    }
   51     51   
}
   52     52   
static CSVOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   53     53   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVOutput", "com.amazonaws.s3", "CSVOutput");
   54     54   
static CSVOUTPUT_MEMBER_QUOTE_FIELDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVOutput$QuoteFields", "com.amazonaws.s3", "CSVOutput"),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "quote_fields",
          57  +
    "QuoteFields",
   58     58   
    0,
   59     59   
);
   60     60   
static CSVOUTPUT_MEMBER_QUOTE_ESCAPE_CHARACTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVOutput$QuoteEscapeCharacter", "com.amazonaws.s3", "CSVOutput"),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "quote_escape_character",
          63  +
    "QuoteEscapeCharacter",
   64     64   
    1,
   65     65   
);
   66     66   
static CSVOUTPUT_MEMBER_RECORD_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVOutput$RecordDelimiter", "com.amazonaws.s3", "CSVOutput"),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "record_delimiter",
          69  +
    "RecordDelimiter",
   70     70   
    2,
   71     71   
);
   72     72   
static CSVOUTPUT_MEMBER_FIELD_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVOutput$FieldDelimiter", "com.amazonaws.s3", "CSVOutput"),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "field_delimiter",
          75  +
    "FieldDelimiter",
   76     76   
    3,
   77     77   
);
   78     78   
static CSVOUTPUT_MEMBER_QUOTE_CHARACTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#CSVOutput$QuoteCharacter", "com.amazonaws.s3", "CSVOutput"),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "quote_character",
          81  +
    "QuoteCharacter",
   82     82   
    4,
   83     83   
);
   84     84   
static CSVOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   85     85   
    CSVOUTPUT_SCHEMA_ID,
   86     86   
    ::aws_smithy_schema::ShapeType::Structure,
   87     87   
    &[
   88     88   
        &CSVOUTPUT_MEMBER_QUOTE_FIELDS,
   89     89   
        &CSVOUTPUT_MEMBER_QUOTE_ESCAPE_CHARACTER,
   90     90   
        &CSVOUTPUT_MEMBER_RECORD_DELIMITER,
   91     91   
        &CSVOUTPUT_MEMBER_FIELD_DELIMITER,
   92     92   
        &CSVOUTPUT_MEMBER_QUOTE_CHARACTER,
   93     93   
    ],
   94     94   
);
   95     95   
impl CsvOutput {
   96     96   
    /// The schema for this shape.
   97     97   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CSVOUTPUT_SCHEMA;
   98     98   
}
   99     99   
impl ::aws_smithy_schema::serde::SerializableStruct for CsvOutput {
  100    100   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  101    101   
    fn serialize_members(
  102    102   
        &self,
  103    103   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  104    104   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  105    105   
        if let Some(ref val) = self.quote_fields {
  106    106   
            ser.write_string(&CSVOUTPUT_MEMBER_QUOTE_FIELDS, val.as_str())?;
  107    107   
        }
  108    108   
        if let Some(ref val) = self.quote_escape_character {
  109    109   
            ser.write_string(&CSVOUTPUT_MEMBER_QUOTE_ESCAPE_CHARACTER, val)?;
  110    110   
        }
  111    111   
        if let Some(ref val) = self.record_delimiter {
  112    112   
            ser.write_string(&CSVOUTPUT_MEMBER_RECORD_DELIMITER, val)?;
  113    113   
        }
  114    114   
        if let Some(ref val) = self.field_delimiter {
  115    115   
            ser.write_string(&CSVOUTPUT_MEMBER_FIELD_DELIMITER, val)?;
  116    116   
        }
  117    117   
        if let Some(ref val) = self.quote_character {
  118    118   
            ser.write_string(&CSVOUTPUT_MEMBER_QUOTE_CHARACTER, val)?;
  119    119   
        }
  120    120   
        Ok(())
  121    121   
    }
  122    122   
}
  123    123   
impl CsvOutput {
  124    124   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  125         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  126         -
        deserializer: &mut D,
         125  +
    pub fn deserialize(
         126  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  127    127   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  128    128   
        #[allow(unused_variables, unused_mut)]
  129    129   
        let mut builder = Self::builder();
  130    130   
        #[allow(
  131    131   
            unused_variables,
  132    132   
            unreachable_code,
  133    133   
            clippy::single_match,
  134    134   
            clippy::match_single_binding,
  135    135   
            clippy::diverging_sub_expression
  136    136   
        )]
  137         -
        deserializer.read_struct(&CSVOUTPUT_SCHEMA, (), |_, member, deser| {
         137  +
        deserializer.read_struct(&CSVOUTPUT_SCHEMA, &mut |member, deser| {
  138    138   
            match member.member_index() {
  139    139   
                Some(0) => {
  140    140   
                    builder.quote_fields = Some(crate::types::QuoteFields::from(deser.read_string(member)?.as_str()));
  141    141   
                }
  142    142   
                Some(1) => {
  143    143   
                    builder.quote_escape_character = Some(deser.read_string(member)?);
  144    144   
                }
  145    145   
                Some(2) => {
  146    146   
                    builder.record_delimiter = Some(deser.read_string(member)?);
  147    147   
                }
  148    148   
                Some(3) => {
  149    149   
                    builder.field_delimiter = Some(deser.read_string(member)?);
  150    150   
                }
  151    151   
                Some(4) => {
  152    152   
                    builder.quote_character = Some(deser.read_string(member)?);
  153    153   
                }
  154    154   
                _ => {}
  155    155   
            }
  156    156   
            Ok(())
  157    157   
        })?;
  158    158   
        Ok(builder.build())
  159    159   
    }
  160    160   
}
         161  +
impl CsvOutput {
         162  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         163  +
    pub fn deserialize_with_response(
         164  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         165  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         166  +
        _status: u16,
         167  +
        _body: &[u8],
         168  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         169  +
        Self::deserialize(deserializer)
         170  +
    }
         171  +
}
  161    172   
impl CsvOutput {
  162    173   
    /// Creates a new builder-style object to manufacture [`CsvOutput`](crate::types::CsvOutput).
  163    174   
    pub fn builder() -> crate::types::builders::CsvOutputBuilder {
  164    175   
        crate::types::builders::CsvOutputBuilder::default()
  165    176   
    }
  166    177   
}
  167    178   
  168    179   
/// A builder for [`CsvOutput`](crate::types::CsvOutput).
  169    180   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  170    181   
#[non_exhaustive]

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

@@ -10,10 +147,158 @@
   30     30   
    /// <p>The number of years that you want to specify for the default retention period. Must be used with <code>Mode</code>.</p>
   31     31   
    pub fn years(&self) -> ::std::option::Option<i32> {
   32     32   
        self.years
   33     33   
    }
   34     34   
}
   35     35   
static DEFAULTRETENTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   36     36   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DefaultRetention", "com.amazonaws.s3", "DefaultRetention");
   37     37   
static DEFAULTRETENTION_MEMBER_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DefaultRetention$Mode", "com.amazonaws.s3", "DefaultRetention"),
   39     39   
    ::aws_smithy_schema::ShapeType::String,
   40         -
    "mode",
          40  +
    "Mode",
   41     41   
    0,
   42     42   
);
   43     43   
static DEFAULTRETENTION_MEMBER_DAYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DefaultRetention$Days", "com.amazonaws.s3", "DefaultRetention"),
   45     45   
    ::aws_smithy_schema::ShapeType::Integer,
   46         -
    "days",
          46  +
    "Days",
   47     47   
    1,
   48     48   
);
   49     49   
static DEFAULTRETENTION_MEMBER_YEARS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DefaultRetention$Years", "com.amazonaws.s3", "DefaultRetention"),
   51     51   
    ::aws_smithy_schema::ShapeType::Integer,
   52         -
    "years",
          52  +
    "Years",
   53     53   
    2,
   54     54   
);
   55     55   
static DEFAULTRETENTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   56     56   
    DEFAULTRETENTION_SCHEMA_ID,
   57     57   
    ::aws_smithy_schema::ShapeType::Structure,
   58     58   
    &[
   59     59   
        &DEFAULTRETENTION_MEMBER_MODE,
   60     60   
        &DEFAULTRETENTION_MEMBER_DAYS,
   61     61   
        &DEFAULTRETENTION_MEMBER_YEARS,
   62     62   
    ],
   63     63   
);
   64     64   
impl DefaultRetention {
   65     65   
    /// The schema for this shape.
   66     66   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEFAULTRETENTION_SCHEMA;
   67     67   
}
   68     68   
impl ::aws_smithy_schema::serde::SerializableStruct for DefaultRetention {
   69     69   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   70     70   
    fn serialize_members(
   71     71   
        &self,
   72     72   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   73     73   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   74     74   
        if let Some(ref val) = self.mode {
   75     75   
            ser.write_string(&DEFAULTRETENTION_MEMBER_MODE, val.as_str())?;
   76     76   
        }
   77     77   
        if let Some(ref val) = self.days {
   78     78   
            ser.write_integer(&DEFAULTRETENTION_MEMBER_DAYS, *val)?;
   79     79   
        }
   80     80   
        if let Some(ref val) = self.years {
   81     81   
            ser.write_integer(&DEFAULTRETENTION_MEMBER_YEARS, *val)?;
   82     82   
        }
   83     83   
        Ok(())
   84     84   
    }
   85     85   
}
   86     86   
impl DefaultRetention {
   87     87   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   88         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   89         -
        deserializer: &mut D,
          88  +
    pub fn deserialize(
          89  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   90     90   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   91     91   
        #[allow(unused_variables, unused_mut)]
   92     92   
        let mut builder = Self::builder();
   93     93   
        #[allow(
   94     94   
            unused_variables,
   95     95   
            unreachable_code,
   96     96   
            clippy::single_match,
   97     97   
            clippy::match_single_binding,
   98     98   
            clippy::diverging_sub_expression
   99     99   
        )]
  100         -
        deserializer.read_struct(&DEFAULTRETENTION_SCHEMA, (), |_, member, deser| {
         100  +
        deserializer.read_struct(&DEFAULTRETENTION_SCHEMA, &mut |member, deser| {
  101    101   
            match member.member_index() {
  102    102   
                Some(0) => {
  103    103   
                    builder.mode = Some(crate::types::ObjectLockRetentionMode::from(deser.read_string(member)?.as_str()));
  104    104   
                }
  105    105   
                Some(1) => {
  106    106   
                    builder.days = Some(deser.read_integer(member)?);
  107    107   
                }
  108    108   
                Some(2) => {
  109    109   
                    builder.years = Some(deser.read_integer(member)?);
  110    110   
                }
  111    111   
                _ => {}
  112    112   
            }
  113    113   
            Ok(())
  114    114   
        })?;
  115    115   
        Ok(builder.build())
  116    116   
    }
  117    117   
}
         118  +
impl DefaultRetention {
         119  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         120  +
    pub fn deserialize_with_response(
         121  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         122  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         123  +
        _status: u16,
         124  +
        _body: &[u8],
         125  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         126  +
        Self::deserialize(deserializer)
         127  +
    }
         128  +
}
  118    129   
impl DefaultRetention {
  119    130   
    /// Creates a new builder-style object to manufacture [`DefaultRetention`](crate::types::DefaultRetention).
  120    131   
    pub fn builder() -> crate::types::builders::DefaultRetentionBuilder {
  121    132   
        crate::types::builders::DefaultRetentionBuilder::default()
  122    133   
    }
  123    134   
}
  124    135   
  125    136   
/// A builder for [`DefaultRetention`](crate::types::DefaultRetention).
  126    137   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  127    138   
#[non_exhaustive]

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

@@ -2,2 +144,153 @@
   22     22   
    /// <p>Element to enable quiet mode for the request. When you add this element, you must set its value to <code>true</code>.</p>
   23     23   
    pub fn quiet(&self) -> ::std::option::Option<bool> {
   24     24   
        self.quiet
   25     25   
    }
   26     26   
}
   27     27   
static DELETE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   28     28   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Delete", "com.amazonaws.s3", "Delete");
   29     29   
static DELETE_MEMBER_OBJECTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Delete$Objects", "com.amazonaws.s3", "Delete"),
   31     31   
    ::aws_smithy_schema::ShapeType::List,
   32         -
    "objects",
          32  +
    "Objects",
   33     33   
    0,
   34     34   
)
   35     35   
.with_xml_name("Object")
   36     36   
.with_xml_flattened();
   37     37   
static DELETE_MEMBER_QUIET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Delete$Quiet", "com.amazonaws.s3", "Delete"),
   39     39   
    ::aws_smithy_schema::ShapeType::Boolean,
   40         -
    "quiet",
          40  +
    "Quiet",
   41     41   
    1,
   42     42   
);
   43     43   
static DELETE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   44     44   
    DELETE_SCHEMA_ID,
   45     45   
    ::aws_smithy_schema::ShapeType::Structure,
   46     46   
    &[&DELETE_MEMBER_OBJECTS, &DELETE_MEMBER_QUIET],
   47     47   
);
   48     48   
impl Delete {
   49     49   
    /// The schema for this shape.
   50     50   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETE_SCHEMA;
   51     51   
}
   52     52   
impl ::aws_smithy_schema::serde::SerializableStruct for Delete {
   53     53   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   54     54   
    fn serialize_members(
   55     55   
        &self,
   56     56   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   57     57   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   58     58   
        {
   59     59   
            let val = &self.objects;
   60     60   
   61     61   
            ser.write_list(&DELETE_MEMBER_OBJECTS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   62     62   
                for item in val {
   63     63   
                    ser.write_struct(crate::types::ObjectIdentifier::SCHEMA, item)?;
   64     64   
                }
   65     65   
                Ok(())
   66     66   
            })?;
   67     67   
        }
   68     68   
        if let Some(ref val) = self.quiet {
   69     69   
            ser.write_boolean(&DELETE_MEMBER_QUIET, *val)?;
   70     70   
        }
   71     71   
        Ok(())
   72     72   
    }
   73     73   
}
   74     74   
impl Delete {
   75     75   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   76         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   77         -
        deserializer: &mut D,
          76  +
    pub fn deserialize(
          77  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   78     78   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   79     79   
        #[allow(unused_variables, unused_mut)]
   80     80   
        let mut builder = Self::builder();
   81     81   
        #[allow(
   82     82   
            unused_variables,
   83     83   
            unreachable_code,
   84     84   
            clippy::single_match,
   85     85   
            clippy::match_single_binding,
   86     86   
            clippy::diverging_sub_expression
   87     87   
        )]
   88         -
        deserializer.read_struct(&DELETE_SCHEMA, (), |_, member, deser| {
          88  +
        deserializer.read_struct(&DELETE_SCHEMA, &mut |member, deser| {
   89     89   
            match member.member_index() {
   90     90   
                Some(0) => {
   91     91   
                    builder.objects = Some({
   92         -
                        let container = if let Some(cap) = deser.container_size() {
   93         -
                            Vec::with_capacity(cap)
   94         -
                        } else {
   95         -
                            Vec::new()
   96         -
                        };
   97         -
                        deser.read_list(member, container, |mut list, deser| {
   98         -
                            list.push(crate::types::ObjectIdentifier::deserialize(deser)?);
   99         -
                            Ok(list)
  100         -
                        })?
          92  +
                        let mut container = Vec::new();
          93  +
                        deser.read_list(member, &mut |deser| {
          94  +
                            container.push(crate::types::ObjectIdentifier::deserialize(deser)?);
          95  +
                            Ok(())
          96  +
                        })?;
          97  +
                        container
  101     98   
                    });
  102     99   
                }
  103    100   
                Some(1) => {
  104    101   
                    builder.quiet = Some(deser.read_boolean(member)?);
  105    102   
                }
  106    103   
                _ => {}
  107    104   
            }
  108    105   
            Ok(())
  109    106   
        })?;
         107  +
        builder.objects = builder.objects.or(Some(Vec::new()));
  110    108   
        builder
  111    109   
            .build()
  112    110   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  113    111   
    }
  114    112   
}
         113  +
impl Delete {
         114  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         115  +
    pub fn deserialize_with_response(
         116  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         117  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         118  +
        _status: u16,
         119  +
        _body: &[u8],
         120  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         121  +
        Self::deserialize(deserializer)
         122  +
    }
         123  +
}
  115    124   
impl Delete {
  116    125   
    /// Creates a new builder-style object to manufacture [`Delete`](crate::types::Delete).
  117    126   
    pub fn builder() -> crate::types::builders::DeleteBuilder {
  118    127   
        crate::types::builders::DeleteBuilder::default()
  119    128   
    }
  120    129   
}
  121    130   
  122    131   
/// A builder for [`Delete`](crate::types::Delete).
  123    132   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  124    133   
#[non_exhaustive]

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

@@ -15,15 +178,189 @@
   35     35   
    /// <p>Date and time when the object was last modified.</p>
   36     36   
    pub fn last_modified(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
   37     37   
        self.last_modified.as_ref()
   38     38   
    }
   39     39   
}
   40     40   
static DELETEMARKERENTRY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   41     41   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerEntry", "com.amazonaws.s3", "DeleteMarkerEntry");
   42     42   
static DELETEMARKERENTRY_MEMBER_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerEntry$Owner", "com.amazonaws.s3", "DeleteMarkerEntry"),
   44     44   
    ::aws_smithy_schema::ShapeType::Structure,
   45         -
    "owner",
          45  +
    "Owner",
   46     46   
    0,
   47     47   
);
   48     48   
static DELETEMARKERENTRY_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerEntry$Key", "com.amazonaws.s3", "DeleteMarkerEntry"),
   50     50   
    ::aws_smithy_schema::ShapeType::String,
   51         -
    "key",
          51  +
    "Key",
   52     52   
    1,
   53     53   
);
   54     54   
static DELETEMARKERENTRY_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerEntry$VersionId", "com.amazonaws.s3", "DeleteMarkerEntry"),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "version_id",
          57  +
    "VersionId",
   58     58   
    2,
   59     59   
);
   60     60   
static DELETEMARKERENTRY_MEMBER_IS_LATEST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerEntry$IsLatest", "com.amazonaws.s3", "DeleteMarkerEntry"),
   62     62   
    ::aws_smithy_schema::ShapeType::Boolean,
   63         -
    "is_latest",
          63  +
    "IsLatest",
   64     64   
    3,
   65     65   
);
   66     66   
static DELETEMARKERENTRY_MEMBER_LAST_MODIFIED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerEntry$LastModified", "com.amazonaws.s3", "DeleteMarkerEntry"),
   68     68   
    ::aws_smithy_schema::ShapeType::Timestamp,
   69         -
    "last_modified",
          69  +
    "LastModified",
   70     70   
    4,
   71     71   
);
   72     72   
static DELETEMARKERENTRY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   73     73   
    DELETEMARKERENTRY_SCHEMA_ID,
   74     74   
    ::aws_smithy_schema::ShapeType::Structure,
   75     75   
    &[
   76     76   
        &DELETEMARKERENTRY_MEMBER_OWNER,
   77     77   
        &DELETEMARKERENTRY_MEMBER_KEY,
   78     78   
        &DELETEMARKERENTRY_MEMBER_VERSION_ID,
   79     79   
        &DELETEMARKERENTRY_MEMBER_IS_LATEST,
   80     80   
        &DELETEMARKERENTRY_MEMBER_LAST_MODIFIED,
   81     81   
    ],
   82     82   
);
   83     83   
impl DeleteMarkerEntry {
   84     84   
    /// The schema for this shape.
   85     85   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEMARKERENTRY_SCHEMA;
   86     86   
}
   87     87   
impl ::aws_smithy_schema::serde::SerializableStruct for DeleteMarkerEntry {
   88     88   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   89     89   
    fn serialize_members(
   90     90   
        &self,
   91     91   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   92     92   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   93     93   
        if let Some(ref val) = self.owner {
   94     94   
            ser.write_struct(&DELETEMARKERENTRY_MEMBER_OWNER, val)?;
   95     95   
        }
   96     96   
        if let Some(ref val) = self.key {
   97     97   
            ser.write_string(&DELETEMARKERENTRY_MEMBER_KEY, val)?;
   98     98   
        }
   99     99   
        if let Some(ref val) = self.version_id {
  100    100   
            ser.write_string(&DELETEMARKERENTRY_MEMBER_VERSION_ID, val)?;
  101    101   
        }
  102    102   
        if let Some(ref val) = self.is_latest {
  103    103   
            ser.write_boolean(&DELETEMARKERENTRY_MEMBER_IS_LATEST, *val)?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.last_modified {
  106    106   
            ser.write_timestamp(&DELETEMARKERENTRY_MEMBER_LAST_MODIFIED, val)?;
  107    107   
        }
  108    108   
        Ok(())
  109    109   
    }
  110    110   
}
  111    111   
impl DeleteMarkerEntry {
  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(&DELETEMARKERENTRY_SCHEMA, (), |_, member, deser| {
         125  +
        deserializer.read_struct(&DELETEMARKERENTRY_SCHEMA, &mut |member, deser| {
  126    126   
            match member.member_index() {
  127    127   
                Some(0) => {
  128    128   
                    builder.owner = Some(crate::types::Owner::deserialize(deser)?);
  129    129   
                }
  130    130   
                Some(1) => {
  131    131   
                    builder.key = Some(deser.read_string(member)?);
  132    132   
                }
  133    133   
                Some(2) => {
  134    134   
                    builder.version_id = Some(deser.read_string(member)?);
  135    135   
                }
  136    136   
                Some(3) => {
  137    137   
                    builder.is_latest = Some(deser.read_boolean(member)?);
  138    138   
                }
  139    139   
                Some(4) => {
  140    140   
                    builder.last_modified = Some(deser.read_timestamp(member)?);
  141    141   
                }
  142    142   
                _ => {}
  143    143   
            }
  144    144   
            Ok(())
  145    145   
        })?;
  146    146   
        Ok(builder.build())
  147    147   
    }
  148    148   
}
         149  +
impl DeleteMarkerEntry {
         150  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         151  +
    pub fn deserialize_with_response(
         152  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         153  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         154  +
        _status: u16,
         155  +
        _body: &[u8],
         156  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         157  +
        Self::deserialize(deserializer)
         158  +
    }
         159  +
}
  149    160   
impl DeleteMarkerEntry {
  150    161   
    /// Creates a new builder-style object to manufacture [`DeleteMarkerEntry`](crate::types::DeleteMarkerEntry).
  151    162   
    pub fn builder() -> crate::types::builders::DeleteMarkerEntryBuilder {
  152    163   
        crate::types::builders::DeleteMarkerEntryBuilder::default()
  153    164   
    }
  154    165   
}
  155    166   
  156    167   
/// A builder for [`DeleteMarkerEntry`](crate::types::DeleteMarkerEntry).
  157    168   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  158    169   
#[non_exhaustive]