AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

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

@@ -1,1 +100,111 @@
   11     11   
    /// <p>Indicates whether the specified object has a legal hold in place.</p>
   12     12   
    pub fn status(&self) -> ::std::option::Option<&crate::types::ObjectLockLegalHoldStatus> {
   13     13   
        self.status.as_ref()
   14     14   
    }
   15     15   
}
   16     16   
static OBJECTLOCKLEGALHOLD_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectLockLegalHold", "com.amazonaws.s3", "ObjectLockLegalHold");
   18     18   
static OBJECTLOCKLEGALHOLD_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectLockLegalHold$Status", "com.amazonaws.s3", "ObjectLockLegalHold"),
   20     20   
    ::aws_smithy_schema::ShapeType::String,
   21         -
    "status",
          21  +
    "Status",
   22     22   
    0,
   23     23   
);
   24     24   
static OBJECTLOCKLEGALHOLD_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   25     25   
    OBJECTLOCKLEGALHOLD_SCHEMA_ID,
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    &[&OBJECTLOCKLEGALHOLD_MEMBER_STATUS],
   28     28   
);
   29     29   
impl ObjectLockLegalHold {
   30     30   
    /// The schema for this shape.
   31     31   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OBJECTLOCKLEGALHOLD_SCHEMA;
   32     32   
}
   33     33   
impl ::aws_smithy_schema::serde::SerializableStruct for ObjectLockLegalHold {
   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.status {
   40     40   
            ser.write_string(&OBJECTLOCKLEGALHOLD_MEMBER_STATUS, val.as_str())?;
   41     41   
        }
   42     42   
        Ok(())
   43     43   
    }
   44     44   
}
   45     45   
impl ObjectLockLegalHold {
   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(&OBJECTLOCKLEGALHOLD_SCHEMA, (), |_, member, deser| {
          59  +
        deserializer.read_struct(&OBJECTLOCKLEGALHOLD_SCHEMA, &mut |member, deser| {
   60     60   
            match member.member_index() {
   61     61   
                Some(0) => {
   62     62   
                    builder.status = Some(crate::types::ObjectLockLegalHoldStatus::from(deser.read_string(member)?.as_str()));
   63     63   
                }
   64     64   
                _ => {}
   65     65   
            }
   66     66   
            Ok(())
   67     67   
        })?;
   68     68   
        Ok(builder.build())
   69     69   
    }
   70     70   
}
          71  +
impl ObjectLockLegalHold {
          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 ObjectLockLegalHold {
   72     83   
    /// Creates a new builder-style object to manufacture [`ObjectLockLegalHold`](crate::types::ObjectLockLegalHold).
   73     84   
    pub fn builder() -> crate::types::builders::ObjectLockLegalHoldBuilder {
   74     85   
        crate::types::builders::ObjectLockLegalHoldBuilder::default()
   75     86   
    }
   76     87   
}
   77     88   
   78     89   
/// A builder for [`ObjectLockLegalHold`](crate::types::ObjectLockLegalHold).
   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/_object_lock_retention.rs

@@ -1,1 +122,134 @@
   17     17   
    /// <p>The date on which this Object Lock Retention will expire.</p>
   18     18   
    pub fn retain_until_date(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
   19     19   
        self.retain_until_date.as_ref()
   20     20   
    }
   21     21   
}
   22     22   
static OBJECTLOCKRETENTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectLockRetention", "com.amazonaws.s3", "ObjectLockRetention");
   24     24   
static OBJECTLOCKRETENTION_MEMBER_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectLockRetention$Mode", "com.amazonaws.s3", "ObjectLockRetention"),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "mode",
          27  +
    "Mode",
   28     28   
    0,
   29     29   
);
   30     30   
static OBJECTLOCKRETENTION_MEMBER_RETAIN_UNTIL_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static(
   32     32   
        "com.amazonaws.s3#ObjectLockRetention$RetainUntilDate",
   33     33   
        "com.amazonaws.s3",
   34     34   
        "ObjectLockRetention",
   35     35   
    ),
   36     36   
    ::aws_smithy_schema::ShapeType::Timestamp,
   37         -
    "retain_until_date",
          37  +
    "RetainUntilDate",
   38     38   
    1,
   39         -
);
          39  +
)
          40  +
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
   40     41   
static OBJECTLOCKRETENTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   41     42   
    OBJECTLOCKRETENTION_SCHEMA_ID,
   42     43   
    ::aws_smithy_schema::ShapeType::Structure,
   43     44   
    &[&OBJECTLOCKRETENTION_MEMBER_MODE, &OBJECTLOCKRETENTION_MEMBER_RETAIN_UNTIL_DATE],
   44     45   
);
   45     46   
impl ObjectLockRetention {
   46     47   
    /// The schema for this shape.
   47     48   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OBJECTLOCKRETENTION_SCHEMA;
   48     49   
}
   49     50   
impl ::aws_smithy_schema::serde::SerializableStruct for ObjectLockRetention {
   50     51   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   51     52   
    fn serialize_members(
   52     53   
        &self,
   53     54   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   54     55   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   55     56   
        if let Some(ref val) = self.mode {
   56     57   
            ser.write_string(&OBJECTLOCKRETENTION_MEMBER_MODE, val.as_str())?;
   57     58   
        }
   58     59   
        if let Some(ref val) = self.retain_until_date {
   59     60   
            ser.write_timestamp(&OBJECTLOCKRETENTION_MEMBER_RETAIN_UNTIL_DATE, val)?;
   60     61   
        }
   61     62   
        Ok(())
   62     63   
    }
   63     64   
}
   64     65   
impl ObjectLockRetention {
   65     66   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   66         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   67         -
        deserializer: &mut D,
          67  +
    pub fn deserialize(
          68  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   68     69   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   69     70   
        #[allow(unused_variables, unused_mut)]
   70     71   
        let mut builder = Self::builder();
   71     72   
        #[allow(
   72     73   
            unused_variables,
   73     74   
            unreachable_code,
   74     75   
            clippy::single_match,
   75     76   
            clippy::match_single_binding,
   76     77   
            clippy::diverging_sub_expression
   77     78   
        )]
   78         -
        deserializer.read_struct(&OBJECTLOCKRETENTION_SCHEMA, (), |_, member, deser| {
          79  +
        deserializer.read_struct(&OBJECTLOCKRETENTION_SCHEMA, &mut |member, deser| {
   79     80   
            match member.member_index() {
   80     81   
                Some(0) => {
   81     82   
                    builder.mode = Some(crate::types::ObjectLockRetentionMode::from(deser.read_string(member)?.as_str()));
   82     83   
                }
   83     84   
                Some(1) => {
   84     85   
                    builder.retain_until_date = Some(deser.read_timestamp(member)?);
   85     86   
                }
   86     87   
                _ => {}
   87     88   
            }
   88     89   
            Ok(())
   89     90   
        })?;
   90     91   
        Ok(builder.build())
   91     92   
    }
   92     93   
}
          94  +
impl ObjectLockRetention {
          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  +
}
   93    105   
impl ObjectLockRetention {
   94    106   
    /// Creates a new builder-style object to manufacture [`ObjectLockRetention`](crate::types::ObjectLockRetention).
   95    107   
    pub fn builder() -> crate::types::builders::ObjectLockRetentionBuilder {
   96    108   
        crate::types::builders::ObjectLockRetentionBuilder::default()
   97    109   
    }
   98    110   
}
   99    111   
  100    112   
/// A builder for [`ObjectLockRetention`](crate::types::ObjectLockRetention).
  101    113   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  102    114   
#[non_exhaustive]

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

@@ -1,1 +100,111 @@
   11     11   
    /// <p>The default Object Lock retention mode and period that you want to apply to new objects placed in the specified bucket. Bucket settings require both a mode and a period. The period can be either <code>Days</code> or <code>Years</code> but you must select one. You cannot specify <code>Days</code> and <code>Years</code> at the same time.</p>
   12     12   
    pub fn default_retention(&self) -> ::std::option::Option<&crate::types::DefaultRetention> {
   13     13   
        self.default_retention.as_ref()
   14     14   
    }
   15     15   
}
   16     16   
static OBJECTLOCKRULE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectLockRule", "com.amazonaws.s3", "ObjectLockRule");
   18     18   
static OBJECTLOCKRULE_MEMBER_DEFAULT_RETENTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectLockRule$DefaultRetention", "com.amazonaws.s3", "ObjectLockRule"),
   20     20   
    ::aws_smithy_schema::ShapeType::Structure,
   21         -
    "default_retention",
          21  +
    "DefaultRetention",
   22     22   
    0,
   23     23   
);
   24     24   
static OBJECTLOCKRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   25     25   
    OBJECTLOCKRULE_SCHEMA_ID,
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    &[&OBJECTLOCKRULE_MEMBER_DEFAULT_RETENTION],
   28     28   
);
   29     29   
impl ObjectLockRule {
   30     30   
    /// The schema for this shape.
   31     31   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OBJECTLOCKRULE_SCHEMA;
   32     32   
}
   33     33   
impl ::aws_smithy_schema::serde::SerializableStruct for ObjectLockRule {
   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.default_retention {
   40     40   
            ser.write_struct(&OBJECTLOCKRULE_MEMBER_DEFAULT_RETENTION, val)?;
   41     41   
        }
   42     42   
        Ok(())
   43     43   
    }
   44     44   
}
   45     45   
impl ObjectLockRule {
   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(&OBJECTLOCKRULE_SCHEMA, (), |_, member, deser| {
          59  +
        deserializer.read_struct(&OBJECTLOCKRULE_SCHEMA, &mut |member, deser| {
   60     60   
            match member.member_index() {
   61     61   
                Some(0) => {
   62     62   
                    builder.default_retention = Some(crate::types::DefaultRetention::deserialize(deser)?);
   63     63   
                }
   64     64   
                _ => {}
   65     65   
            }
   66     66   
            Ok(())
   67     67   
        })?;
   68     68   
        Ok(builder.build())
   69     69   
    }
   70     70   
}
          71  +
impl ObjectLockRule {
          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 ObjectLockRule {
   72     83   
    /// Creates a new builder-style object to manufacture [`ObjectLockRule`](crate::types::ObjectLockRule).
   73     84   
    pub fn builder() -> crate::types::builders::ObjectLockRuleBuilder {
   74     85   
        crate::types::builders::ObjectLockRuleBuilder::default()
   75     86   
    }
   76     87   
}
   77     88   
   78     89   
/// A builder for [`ObjectLockRule`](crate::types::ObjectLockRule).
   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/_object_part.rs

@@ -27,27 +216,227 @@
   47     47   
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> checksum of the part. This checksum is present if the multipart upload request was created with the <code>SHA256</code> checksum algorithm. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   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 OBJECTPART_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   53     53   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectPart", "com.amazonaws.s3", "ObjectPart");
   54     54   
static OBJECTPART_MEMBER_PART_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectPart$PartNumber", "com.amazonaws.s3", "ObjectPart"),
   56     56   
    ::aws_smithy_schema::ShapeType::Integer,
   57         -
    "part_number",
          57  +
    "PartNumber",
   58     58   
    0,
   59     59   
);
   60     60   
static OBJECTPART_MEMBER_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectPart$Size", "com.amazonaws.s3", "ObjectPart"),
   62     62   
    ::aws_smithy_schema::ShapeType::Long,
   63         -
    "size",
          63  +
    "Size",
   64     64   
    1,
   65     65   
);
   66     66   
static OBJECTPART_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectPart$ChecksumCRC32", "com.amazonaws.s3", "ObjectPart"),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "checksum_crc32",
          69  +
    "ChecksumCRC32",
   70     70   
    2,
   71     71   
);
   72     72   
static OBJECTPART_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#ObjectPart$ChecksumCRC32C", "com.amazonaws.s3", "ObjectPart"),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "checksum_crc32_c",
          75  +
    "ChecksumCRC32C",
   76     76   
    3,
   77     77   
);
   78     78   
static OBJECTPART_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#ObjectPart$ChecksumCRC64NVME", "com.amazonaws.s3", "ObjectPart"),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "checksum_crc64_nvme",
          81  +
    "ChecksumCRC64NVME",
   82     82   
    4,
   83     83   
);
   84     84   
static OBJECTPART_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectPart$ChecksumSHA1", "com.amazonaws.s3", "ObjectPart"),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "checksum_sha1",
          87  +
    "ChecksumSHA1",
   88     88   
    5,
   89     89   
);
   90     90   
static OBJECTPART_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectPart$ChecksumSHA256", "com.amazonaws.s3", "ObjectPart"),
   92     92   
    ::aws_smithy_schema::ShapeType::String,
   93         -
    "checksum_sha256",
          93  +
    "ChecksumSHA256",
   94     94   
    6,
   95     95   
);
   96     96   
static OBJECTPART_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   97     97   
    OBJECTPART_SCHEMA_ID,
   98     98   
    ::aws_smithy_schema::ShapeType::Structure,
   99     99   
    &[
  100    100   
        &OBJECTPART_MEMBER_PART_NUMBER,
  101    101   
        &OBJECTPART_MEMBER_SIZE,
  102    102   
        &OBJECTPART_MEMBER_CHECKSUM_CRC32,
  103    103   
        &OBJECTPART_MEMBER_CHECKSUM_CRC32_C,
  104    104   
        &OBJECTPART_MEMBER_CHECKSUM_CRC64_NVME,
  105    105   
        &OBJECTPART_MEMBER_CHECKSUM_SHA1,
  106    106   
        &OBJECTPART_MEMBER_CHECKSUM_SHA256,
  107    107   
    ],
  108    108   
);
  109    109   
impl ObjectPart {
  110    110   
    /// The schema for this shape.
  111    111   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OBJECTPART_SCHEMA;
  112    112   
}
  113    113   
impl ::aws_smithy_schema::serde::SerializableStruct for ObjectPart {
  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.part_number {
  120    120   
            ser.write_integer(&OBJECTPART_MEMBER_PART_NUMBER, *val)?;
  121    121   
        }
  122    122   
        if let Some(ref val) = self.size {
  123    123   
            ser.write_long(&OBJECTPART_MEMBER_SIZE, *val)?;
  124    124   
        }
  125    125   
        if let Some(ref val) = self.checksum_crc32 {
  126    126   
            ser.write_string(&OBJECTPART_MEMBER_CHECKSUM_CRC32, val)?;
  127    127   
        }
  128    128   
        if let Some(ref val) = self.checksum_crc32_c {
  129    129   
            ser.write_string(&OBJECTPART_MEMBER_CHECKSUM_CRC32_C, val)?;
  130    130   
        }
  131    131   
        if let Some(ref val) = self.checksum_crc64_nvme {
  132    132   
            ser.write_string(&OBJECTPART_MEMBER_CHECKSUM_CRC64_NVME, val)?;
  133    133   
        }
  134    134   
        if let Some(ref val) = self.checksum_sha1 {
  135    135   
            ser.write_string(&OBJECTPART_MEMBER_CHECKSUM_SHA1, val)?;
  136    136   
        }
  137    137   
        if let Some(ref val) = self.checksum_sha256 {
  138    138   
            ser.write_string(&OBJECTPART_MEMBER_CHECKSUM_SHA256, val)?;
  139    139   
        }
  140    140   
        Ok(())
  141    141   
    }
  142    142   
}
  143    143   
impl ObjectPart {
  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(&OBJECTPART_SCHEMA, (), |_, member, deser| {
         157  +
        deserializer.read_struct(&OBJECTPART_SCHEMA, &mut |member, deser| {
  158    158   
            match member.member_index() {
  159    159   
                Some(0) => {
  160    160   
                    builder.part_number = Some(deser.read_integer(member)?);
  161    161   
                }
  162    162   
                Some(1) => {
  163    163   
                    builder.size = Some(deser.read_long(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 ObjectPart {
         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 ObjectPart {
  188    199   
    /// Creates a new builder-style object to manufacture [`ObjectPart`](crate::types::ObjectPart).
  189    200   
    pub fn builder() -> crate::types::builders::ObjectPartBuilder {
  190    201   
        crate::types::builders::ObjectPartBuilder::default()
  191    202   
    }
  192    203   
}
  193    204   
  194    205   
/// A builder for [`ObjectPart`](crate::types::ObjectPart).
  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/_object_version.rs

@@ -53,53 +174,174 @@
   73     73   
    /// <p>Specifies the restoration status of an object. Objects in certain storage classes must be restored before they can be retrieved. For more information about these storage classes and how to work with archived objects, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/archived-objects.html"> Working with archived objects</a> in the <i>Amazon S3 User Guide</i>.</p>
   74     74   
    pub fn restore_status(&self) -> ::std::option::Option<&crate::types::RestoreStatus> {
   75     75   
        self.restore_status.as_ref()
   76     76   
    }
   77     77   
}
   78     78   
static OBJECTVERSION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   79     79   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectVersion", "com.amazonaws.s3", "ObjectVersion");
   80     80   
static OBJECTVERSION_MEMBER_E_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectVersion$ETag", "com.amazonaws.s3", "ObjectVersion"),
   82     82   
    ::aws_smithy_schema::ShapeType::String,
   83         -
    "e_tag",
          83  +
    "ETag",
   84     84   
    0,
   85     85   
);
   86     86   
static OBJECTVERSION_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectVersion$ChecksumAlgorithm", "com.amazonaws.s3", "ObjectVersion"),
   88     88   
    ::aws_smithy_schema::ShapeType::List,
   89         -
    "checksum_algorithm",
          89  +
    "ChecksumAlgorithm",
   90     90   
    1,
   91     91   
)
   92     92   
.with_xml_flattened();
   93     93   
static OBJECTVERSION_MEMBER_CHECKSUM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectVersion$ChecksumType", "com.amazonaws.s3", "ObjectVersion"),
   95     95   
    ::aws_smithy_schema::ShapeType::String,
   96         -
    "checksum_type",
          96  +
    "ChecksumType",
   97     97   
    2,
   98     98   
);
   99     99   
static OBJECTVERSION_MEMBER_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectVersion$Size", "com.amazonaws.s3", "ObjectVersion"),
  101    101   
    ::aws_smithy_schema::ShapeType::Long,
  102         -
    "size",
         102  +
    "Size",
  103    103   
    3,
  104    104   
);
  105    105   
static OBJECTVERSION_MEMBER_STORAGE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectVersion$StorageClass", "com.amazonaws.s3", "ObjectVersion"),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "storage_class",
         108  +
    "StorageClass",
  109    109   
    4,
  110    110   
);
  111    111   
static OBJECTVERSION_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectVersion$Key", "com.amazonaws.s3", "ObjectVersion"),
  113    113   
    ::aws_smithy_schema::ShapeType::String,
  114         -
    "key",
         114  +
    "Key",
  115    115   
    5,
  116    116   
);
  117    117   
static OBJECTVERSION_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectVersion$VersionId", "com.amazonaws.s3", "ObjectVersion"),
  119    119   
    ::aws_smithy_schema::ShapeType::String,
  120         -
    "version_id",
         120  +
    "VersionId",
  121    121   
    6,
  122    122   
);
  123    123   
static OBJECTVERSION_MEMBER_IS_LATEST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectVersion$IsLatest", "com.amazonaws.s3", "ObjectVersion"),
  125    125   
    ::aws_smithy_schema::ShapeType::Boolean,
  126         -
    "is_latest",
         126  +
    "IsLatest",
  127    127   
    7,
  128    128   
);
  129    129   
static OBJECTVERSION_MEMBER_LAST_MODIFIED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectVersion$LastModified", "com.amazonaws.s3", "ObjectVersion"),
  131    131   
    ::aws_smithy_schema::ShapeType::Timestamp,
  132         -
    "last_modified",
         132  +
    "LastModified",
  133    133   
    8,
  134    134   
);
  135    135   
static OBJECTVERSION_MEMBER_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectVersion$Owner", "com.amazonaws.s3", "ObjectVersion"),
  137    137   
    ::aws_smithy_schema::ShapeType::Structure,
  138         -
    "owner",
         138  +
    "Owner",
  139    139   
    9,
  140    140   
);
  141    141   
static OBJECTVERSION_MEMBER_RESTORE_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  142    142   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectVersion$RestoreStatus", "com.amazonaws.s3", "ObjectVersion"),
  143    143   
    ::aws_smithy_schema::ShapeType::Structure,
  144         -
    "restore_status",
         144  +
    "RestoreStatus",
  145    145   
    10,
  146    146   
);
  147    147   
static OBJECTVERSION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  148    148   
    OBJECTVERSION_SCHEMA_ID,
  149    149   
    ::aws_smithy_schema::ShapeType::Structure,
  150    150   
    &[
  151    151   
        &OBJECTVERSION_MEMBER_E_TAG,
  152    152   
        &OBJECTVERSION_MEMBER_CHECKSUM_ALGORITHM,
  153    153   
        &OBJECTVERSION_MEMBER_CHECKSUM_TYPE,
  154    154   
        &OBJECTVERSION_MEMBER_SIZE,
@@ -190,190 +313,321 @@
  210    210   
            ser.write_struct(&OBJECTVERSION_MEMBER_OWNER, val)?;
  211    211   
        }
  212    212   
        if let Some(ref val) = self.restore_status {
  213    213   
            ser.write_struct(&OBJECTVERSION_MEMBER_RESTORE_STATUS, val)?;
  214    214   
        }
  215    215   
        Ok(())
  216    216   
    }
  217    217   
}
  218    218   
impl ObjectVersion {
  219    219   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  220         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  221         -
        deserializer: &mut D,
         220  +
    pub fn deserialize(
         221  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  222    222   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  223    223   
        #[allow(unused_variables, unused_mut)]
  224    224   
        let mut builder = Self::builder();
  225    225   
        #[allow(
  226    226   
            unused_variables,
  227    227   
            unreachable_code,
  228    228   
            clippy::single_match,
  229    229   
            clippy::match_single_binding,
  230    230   
            clippy::diverging_sub_expression
  231    231   
        )]
  232         -
        deserializer.read_struct(&OBJECTVERSION_SCHEMA, (), |_, member, deser| {
         232  +
        deserializer.read_struct(&OBJECTVERSION_SCHEMA, &mut |member, deser| {
  233    233   
            match member.member_index() {
  234    234   
                Some(0) => {
  235    235   
                    builder.e_tag = Some(deser.read_string(member)?);
  236    236   
                }
  237    237   
                Some(1) => {
  238    238   
                    builder.checksum_algorithm = Some({
  239         -
                        let container = if let Some(cap) = deser.container_size() {
  240         -
                            Vec::with_capacity(cap)
  241         -
                        } else {
  242         -
                            Vec::new()
  243         -
                        };
  244         -
                        deser.read_list(member, container, |mut list, deser| {
  245         -
                            list.push(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
  246         -
                            Ok(list)
  247         -
                        })?
         239  +
                        let mut container = Vec::new();
         240  +
                        deser.read_list(member, &mut |deser| {
         241  +
                            container.push(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
         242  +
                            Ok(())
         243  +
                        })?;
         244  +
                        container
  248    245   
                    });
  249    246   
                }
  250    247   
                Some(2) => {
  251    248   
                    builder.checksum_type = Some(crate::types::ChecksumType::from(deser.read_string(member)?.as_str()));
  252    249   
                }
  253    250   
                Some(3) => {
  254    251   
                    builder.size = Some(deser.read_long(member)?);
  255    252   
                }
  256    253   
                Some(4) => {
  257    254   
                    builder.storage_class = Some(crate::types::ObjectVersionStorageClass::from(deser.read_string(member)?.as_str()));
  258    255   
                }
  259    256   
                Some(5) => {
  260    257   
                    builder.key = Some(deser.read_string(member)?);
  261    258   
                }
  262    259   
                Some(6) => {
  263    260   
                    builder.version_id = Some(deser.read_string(member)?);
  264    261   
                }
  265    262   
                Some(7) => {
  266    263   
                    builder.is_latest = Some(deser.read_boolean(member)?);
  267    264   
                }
  268    265   
                Some(8) => {
  269    266   
                    builder.last_modified = Some(deser.read_timestamp(member)?);
  270    267   
                }
  271    268   
                Some(9) => {
  272    269   
                    builder.owner = Some(crate::types::Owner::deserialize(deser)?);
  273    270   
                }
  274    271   
                Some(10) => {
  275    272   
                    builder.restore_status = Some(crate::types::RestoreStatus::deserialize(deser)?);
  276    273   
                }
  277    274   
                _ => {}
  278    275   
            }
  279    276   
            Ok(())
  280    277   
        })?;
  281    278   
        Ok(builder.build())
  282    279   
    }
  283    280   
}
         281  +
impl ObjectVersion {
         282  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         283  +
    pub fn deserialize_with_response(
         284  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         285  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         286  +
        _status: u16,
         287  +
        _body: &[u8],
         288  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         289  +
        Self::deserialize(deserializer)
         290  +
    }
         291  +
}
  284    292   
impl ObjectVersion {
  285    293   
    /// Creates a new builder-style object to manufacture [`ObjectVersion`](crate::types::ObjectVersion).
  286    294   
    pub fn builder() -> crate::types::builders::ObjectVersionBuilder {
  287    295   
        crate::types::builders::ObjectVersionBuilder::default()
  288    296   
    }
  289    297   
}
  290    298   
  291    299   
/// A builder for [`ObjectVersion`](crate::types::ObjectVersion).
  292    300   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  293    301   
#[non_exhaustive]

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

@@ -1,1 +100,111 @@
   11     11   
    /// <p>Describes an S3 location that will receive the results of the restore request.</p>
   12     12   
    pub fn s3(&self) -> ::std::option::Option<&crate::types::S3Location> {
   13     13   
        self.s3.as_ref()
   14     14   
    }
   15     15   
}
   16     16   
static OUTPUTLOCATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#OutputLocation", "com.amazonaws.s3", "OutputLocation");
   18     18   
static OUTPUTLOCATION_MEMBER_S3: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#OutputLocation$S3", "com.amazonaws.s3", "OutputLocation"),
   20     20   
    ::aws_smithy_schema::ShapeType::Structure,
   21         -
    "s3",
          21  +
    "S3",
   22     22   
    0,
   23     23   
);
   24     24   
static OUTPUTLOCATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   25     25   
    OUTPUTLOCATION_SCHEMA_ID,
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    &[&OUTPUTLOCATION_MEMBER_S3],
   28     28   
);
   29     29   
impl OutputLocation {
   30     30   
    /// The schema for this shape.
   31     31   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OUTPUTLOCATION_SCHEMA;
   32     32   
}
   33     33   
impl ::aws_smithy_schema::serde::SerializableStruct for OutputLocation {
   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.s3 {
   40     40   
            ser.write_struct(&OUTPUTLOCATION_MEMBER_S3, val)?;
   41     41   
        }
   42     42   
        Ok(())
   43     43   
    }
   44     44   
}
   45     45   
impl OutputLocation {
   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(&OUTPUTLOCATION_SCHEMA, (), |_, member, deser| {
          59  +
        deserializer.read_struct(&OUTPUTLOCATION_SCHEMA, &mut |member, deser| {
   60     60   
            match member.member_index() {
   61     61   
                Some(0) => {
   62     62   
                    builder.s3 = Some(crate::types::S3Location::deserialize(deser)?);
   63     63   
                }
   64     64   
                _ => {}
   65     65   
            }
   66     66   
            Ok(())
   67     67   
        })?;
   68     68   
        Ok(builder.build())
   69     69   
    }
   70     70   
}
          71  +
impl OutputLocation {
          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 OutputLocation {
   72     83   
    /// Creates a new builder-style object to manufacture [`OutputLocation`](crate::types::OutputLocation).
   73     84   
    pub fn builder() -> crate::types::builders::OutputLocationBuilder {
   74     85   
        crate::types::builders::OutputLocationBuilder::default()
   75     86   
    }
   76     87   
}
   77     88   
   78     89   
/// A builder for [`OutputLocation`](crate::types::OutputLocation).
   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/_output_serialization.rs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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