AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

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

@@ -2,2 +111,122 @@
   22     22   
}
   23     23   
static DELETEMARKERREPLICATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   24     24   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#DeleteMarkerReplication", "com.amazonaws.s3", "DeleteMarkerReplication");
   25     25   
static DELETEMARKERREPLICATION_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   26     26   
    ::aws_smithy_schema::ShapeId::from_static(
   27     27   
        "com.amazonaws.s3#DeleteMarkerReplication$Status",
   28     28   
        "com.amazonaws.s3",
   29     29   
        "DeleteMarkerReplication",
   30     30   
    ),
   31     31   
    ::aws_smithy_schema::ShapeType::String,
   32         -
    "status",
          32  +
    "Status",
   33     33   
    0,
   34     34   
);
   35     35   
static DELETEMARKERREPLICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   36     36   
    DELETEMARKERREPLICATION_SCHEMA_ID,
   37     37   
    ::aws_smithy_schema::ShapeType::Structure,
   38     38   
    &[&DELETEMARKERREPLICATION_MEMBER_STATUS],
   39     39   
);
   40     40   
impl DeleteMarkerReplication {
   41     41   
    /// The schema for this shape.
   42     42   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEMARKERREPLICATION_SCHEMA;
   43     43   
}
   44     44   
impl ::aws_smithy_schema::serde::SerializableStruct for DeleteMarkerReplication {
   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.status {
   51     51   
            ser.write_string(&DELETEMARKERREPLICATION_MEMBER_STATUS, val.as_str())?;
   52     52   
        }
   53     53   
        Ok(())
   54     54   
    }
   55     55   
}
   56     56   
impl DeleteMarkerReplication {
   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(&DELETEMARKERREPLICATION_SCHEMA, (), |_, member, deser| {
          70  +
        deserializer.read_struct(&DELETEMARKERREPLICATION_SCHEMA, &mut |member, deser| {
   71     71   
            match member.member_index() {
   72     72   
                Some(0) => {
   73     73   
                    builder.status = Some(crate::types::DeleteMarkerReplicationStatus::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 DeleteMarkerReplication {
          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 DeleteMarkerReplication {
   83     94   
    /// Creates a new builder-style object to manufacture [`DeleteMarkerReplication`](crate::types::DeleteMarkerReplication).
   84     95   
    pub fn builder() -> crate::types::builders::DeleteMarkerReplicationBuilder {
   85     96   
        crate::types::builders::DeleteMarkerReplicationBuilder::default()
   86     97   
    }
   87     98   
}
   88     99   
   89    100   
/// A builder for [`DeleteMarkerReplication`](crate::types::DeleteMarkerReplication).
   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/_deleted_object.rs

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

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

@@ -32,32 +224,236 @@
   52     52   
    /// <p>A container specifying replication metrics-related settings enabling replication metrics and events.</p>
   53     53   
    pub fn metrics(&self) -> ::std::option::Option<&crate::types::Metrics> {
   54     54   
        self.metrics.as_ref()
   55     55   
    }
   56     56   
}
   57     57   
static DESTINATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   58     58   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination", "com.amazonaws.s3", "Destination");
   59     59   
static DESTINATION_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$Bucket", "com.amazonaws.s3", "Destination"),
   61     61   
    ::aws_smithy_schema::ShapeType::String,
   62         -
    "bucket",
          62  +
    "Bucket",
   63     63   
    0,
   64     64   
);
   65     65   
static DESTINATION_MEMBER_ACCOUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$Account", "com.amazonaws.s3", "Destination"),
   67     67   
    ::aws_smithy_schema::ShapeType::String,
   68         -
    "account",
          68  +
    "Account",
   69     69   
    1,
   70     70   
);
   71     71   
static DESTINATION_MEMBER_STORAGE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$StorageClass", "com.amazonaws.s3", "Destination"),
   73     73   
    ::aws_smithy_schema::ShapeType::String,
   74         -
    "storage_class",
          74  +
    "StorageClass",
   75     75   
    2,
   76     76   
);
   77     77   
static DESTINATION_MEMBER_ACCESS_CONTROL_TRANSLATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$AccessControlTranslation", "com.amazonaws.s3", "Destination"),
   79     79   
    ::aws_smithy_schema::ShapeType::Structure,
   80         -
    "access_control_translation",
          80  +
    "AccessControlTranslation",
   81     81   
    3,
   82     82   
);
   83     83   
static DESTINATION_MEMBER_ENCRYPTION_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$EncryptionConfiguration", "com.amazonaws.s3", "Destination"),
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86         -
    "encryption_configuration",
          86  +
    "EncryptionConfiguration",
   87     87   
    4,
   88     88   
);
   89     89   
static DESTINATION_MEMBER_REPLICATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$ReplicationTime", "com.amazonaws.s3", "Destination"),
   91     91   
    ::aws_smithy_schema::ShapeType::Structure,
   92         -
    "replication_time",
          92  +
    "ReplicationTime",
   93     93   
    5,
   94     94   
);
   95     95   
static DESTINATION_MEMBER_METRICS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Destination$Metrics", "com.amazonaws.s3", "Destination"),
   97     97   
    ::aws_smithy_schema::ShapeType::Structure,
   98         -
    "metrics",
          98  +
    "Metrics",
   99     99   
    6,
  100    100   
);
  101    101   
static DESTINATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  102    102   
    DESTINATION_SCHEMA_ID,
  103    103   
    ::aws_smithy_schema::ShapeType::Structure,
  104    104   
    &[
  105    105   
        &DESTINATION_MEMBER_BUCKET,
  106    106   
        &DESTINATION_MEMBER_ACCOUNT,
  107    107   
        &DESTINATION_MEMBER_STORAGE_CLASS,
  108    108   
        &DESTINATION_MEMBER_ACCESS_CONTROL_TRANSLATION,
  109    109   
        &DESTINATION_MEMBER_ENCRYPTION_CONFIGURATION,
  110    110   
        &DESTINATION_MEMBER_REPLICATION_TIME,
  111    111   
        &DESTINATION_MEMBER_METRICS,
  112    112   
    ],
  113    113   
);
  114    114   
impl Destination {
  115    115   
    /// The schema for this shape.
  116    116   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DESTINATION_SCHEMA;
  117    117   
}
  118    118   
impl ::aws_smithy_schema::serde::SerializableStruct for Destination {
  119    119   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  120    120   
    fn serialize_members(
  121    121   
        &self,
  122    122   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  123    123   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  124    124   
        {
  125    125   
            let val = &self.bucket;
  126    126   
            ser.write_string(&DESTINATION_MEMBER_BUCKET, val)?;
  127    127   
        }
  128    128   
        if let Some(ref val) = self.account {
  129    129   
            ser.write_string(&DESTINATION_MEMBER_ACCOUNT, val)?;
  130    130   
        }
  131    131   
        if let Some(ref val) = self.storage_class {
  132    132   
            ser.write_string(&DESTINATION_MEMBER_STORAGE_CLASS, val.as_str())?;
  133    133   
        }
  134    134   
        if let Some(ref val) = self.access_control_translation {
  135    135   
            ser.write_struct(&DESTINATION_MEMBER_ACCESS_CONTROL_TRANSLATION, val)?;
  136    136   
        }
  137    137   
        if let Some(ref val) = self.encryption_configuration {
  138    138   
            ser.write_struct(&DESTINATION_MEMBER_ENCRYPTION_CONFIGURATION, val)?;
  139    139   
        }
  140    140   
        if let Some(ref val) = self.replication_time {
  141    141   
            ser.write_struct(&DESTINATION_MEMBER_REPLICATION_TIME, val)?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.metrics {
  144    144   
            ser.write_struct(&DESTINATION_MEMBER_METRICS, val)?;
  145    145   
        }
  146    146   
        Ok(())
  147    147   
    }
  148    148   
}
  149    149   
impl Destination {
  150    150   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  151         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  152         -
        deserializer: &mut D,
         151  +
    pub fn deserialize(
         152  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  153    153   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  154    154   
        #[allow(unused_variables, unused_mut)]
  155    155   
        let mut builder = Self::builder();
  156    156   
        #[allow(
  157    157   
            unused_variables,
  158    158   
            unreachable_code,
  159    159   
            clippy::single_match,
  160    160   
            clippy::match_single_binding,
  161    161   
            clippy::diverging_sub_expression
  162    162   
        )]
  163         -
        deserializer.read_struct(&DESTINATION_SCHEMA, (), |_, member, deser| {
         163  +
        deserializer.read_struct(&DESTINATION_SCHEMA, &mut |member, deser| {
  164    164   
            match member.member_index() {
  165    165   
                Some(0) => {
  166    166   
                    builder.bucket = Some(deser.read_string(member)?);
  167    167   
                }
  168    168   
                Some(1) => {
  169    169   
                    builder.account = Some(deser.read_string(member)?);
  170    170   
                }
  171    171   
                Some(2) => {
  172    172   
                    builder.storage_class = Some(crate::types::StorageClass::from(deser.read_string(member)?.as_str()));
  173    173   
                }
  174    174   
                Some(3) => {
  175    175   
                    builder.access_control_translation = Some(crate::types::AccessControlTranslation::deserialize(deser)?);
  176    176   
                }
  177    177   
                Some(4) => {
  178    178   
                    builder.encryption_configuration = Some(crate::types::EncryptionConfiguration::deserialize(deser)?);
  179    179   
                }
  180    180   
                Some(5) => {
  181    181   
                    builder.replication_time = Some(crate::types::ReplicationTime::deserialize(deser)?);
  182    182   
                }
  183    183   
                Some(6) => {
  184    184   
                    builder.metrics = Some(crate::types::Metrics::deserialize(deser)?);
  185    185   
                }
  186    186   
                _ => {}
  187    187   
            }
  188    188   
            Ok(())
  189    189   
        })?;
         190  +
        builder.bucket = builder.bucket.or(Some(String::new()));
  190    191   
        builder
  191    192   
            .build()
  192    193   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  193    194   
    }
  194    195   
}
         196  +
impl Destination {
         197  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         198  +
    pub fn deserialize_with_response(
         199  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         200  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         201  +
        _status: u16,
         202  +
        _body: &[u8],
         203  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         204  +
        Self::deserialize(deserializer)
         205  +
    }
         206  +
}
  195    207   
impl Destination {
  196    208   
    /// Creates a new builder-style object to manufacture [`Destination`](crate::types::Destination).
  197    209   
    pub fn builder() -> crate::types::builders::DestinationBuilder {
  198    210   
        crate::types::builders::DestinationBuilder::default()
  199    211   
    }
  200    212   
}
  201    213   
  202    214   
/// A builder for [`Destination`](crate::types::Destination).
  203    215   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  204    216   
#[non_exhaustive]

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

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

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

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

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

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

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

@@ -1,1 +63,74 @@
   16     16   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   17     17   
    fn serialize_members(
   18     18   
        &self,
   19     19   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   20     20   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   21     21   
        Ok(())
   22     22   
    }
   23     23   
}
   24     24   
impl EndEvent {
   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(&ENDEVENT_SCHEMA, (), |_, member, deser| {
          38  +
        deserializer.read_struct(&ENDEVENT_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 EndEvent {
          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 EndEvent {
   48     59   
    /// Creates a new builder-style object to manufacture [`EndEvent`](crate::types::EndEvent).
   49     60   
    pub fn builder() -> crate::types::builders::EndEventBuilder {
   50     61   
        crate::types::builders::EndEventBuilder::default()
   51     62   
    }
   52     63   
}
   53     64   
   54     65   
/// A builder for [`EndEvent`](crate::types::EndEvent).
   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/_error.rs

@@ -1955,1955 +2100,2111 @@
 1975   1975   
    /// <p>The error message contains a generic description of the error condition in English. It is intended for a human audience. Simple programs display the message directly to the end user if they encounter an error condition they don't know how or don't care to handle. Sophisticated programs with more exhaustive error handling and proper internationalization are more likely to ignore the error message.</p>
 1976   1976   
    pub fn message(&self) -> ::std::option::Option<&str> {
 1977   1977   
        self.message.as_deref()
 1978   1978   
    }
 1979   1979   
}
 1980   1980   
static ERROR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
 1981   1981   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Error", "com.amazonaws.s3", "Error");
 1982   1982   
static ERROR_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1983   1983   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Error$Key", "com.amazonaws.s3", "Error"),
 1984   1984   
    ::aws_smithy_schema::ShapeType::String,
 1985         -
    "key",
        1985  +
    "Key",
 1986   1986   
    0,
 1987   1987   
);
 1988   1988   
static ERROR_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1989   1989   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Error$VersionId", "com.amazonaws.s3", "Error"),
 1990   1990   
    ::aws_smithy_schema::ShapeType::String,
 1991         -
    "version_id",
        1991  +
    "VersionId",
 1992   1992   
    1,
 1993   1993   
);
 1994   1994   
static ERROR_MEMBER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1995   1995   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Error$Code", "com.amazonaws.s3", "Error"),
 1996   1996   
    ::aws_smithy_schema::ShapeType::String,
 1997         -
    "code",
        1997  +
    "Code",
 1998   1998   
    2,
 1999   1999   
);
 2000   2000   
static ERROR_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 2001   2001   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Error$Message", "com.amazonaws.s3", "Error"),
 2002   2002   
    ::aws_smithy_schema::ShapeType::String,
 2003         -
    "message",
        2003  +
    "Message",
 2004   2004   
    3,
 2005   2005   
);
 2006   2006   
static ERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
 2007   2007   
    ERROR_SCHEMA_ID,
 2008   2008   
    ::aws_smithy_schema::ShapeType::Structure,
 2009   2009   
    &[&ERROR_MEMBER_KEY, &ERROR_MEMBER_VERSION_ID, &ERROR_MEMBER_CODE, &ERROR_MEMBER_MESSAGE],
 2010   2010   
);
 2011   2011   
impl Error {
 2012   2012   
    /// The schema for this shape.
 2013   2013   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ERROR_SCHEMA;
 2014   2014   
}
 2015   2015   
impl ::aws_smithy_schema::serde::SerializableStruct for Error {
 2016   2016   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
 2017   2017   
    fn serialize_members(
 2018   2018   
        &self,
 2019   2019   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
 2020   2020   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
 2021   2021   
        if let Some(ref val) = self.key {
 2022   2022   
            ser.write_string(&ERROR_MEMBER_KEY, val)?;
 2023   2023   
        }
 2024   2024   
        if let Some(ref val) = self.version_id {
 2025   2025   
            ser.write_string(&ERROR_MEMBER_VERSION_ID, val)?;
 2026   2026   
        }
 2027   2027   
        if let Some(ref val) = self.code {
 2028   2028   
            ser.write_string(&ERROR_MEMBER_CODE, val)?;
 2029   2029   
        }
 2030   2030   
        if let Some(ref val) = self.message {
 2031   2031   
            ser.write_string(&ERROR_MEMBER_MESSAGE, val)?;
 2032   2032   
        }
 2033   2033   
        Ok(())
 2034   2034   
    }
 2035   2035   
}
 2036   2036   
impl Error {
 2037   2037   
    /// Deserializes this structure from a [`ShapeDeserializer`].
 2038         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
 2039         -
        deserializer: &mut D,
        2038  +
    pub fn deserialize(
        2039  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
 2040   2040   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
 2041   2041   
        #[allow(unused_variables, unused_mut)]
 2042   2042   
        let mut builder = Self::builder();
 2043   2043   
        #[allow(
 2044   2044   
            unused_variables,
 2045   2045   
            unreachable_code,
 2046   2046   
            clippy::single_match,
 2047   2047   
            clippy::match_single_binding,
 2048   2048   
            clippy::diverging_sub_expression
 2049   2049   
        )]
 2050         -
        deserializer.read_struct(&ERROR_SCHEMA, (), |_, member, deser| {
        2050  +
        deserializer.read_struct(&ERROR_SCHEMA, &mut |member, deser| {
 2051   2051   
            match member.member_index() {
 2052   2052   
                Some(0) => {
 2053   2053   
                    builder.key = Some(deser.read_string(member)?);
 2054   2054   
                }
 2055   2055   
                Some(1) => {
 2056   2056   
                    builder.version_id = Some(deser.read_string(member)?);
 2057   2057   
                }
 2058   2058   
                Some(2) => {
 2059   2059   
                    builder.code = Some(deser.read_string(member)?);
 2060   2060   
                }
 2061   2061   
                Some(3) => {
 2062   2062   
                    builder.message = Some(deser.read_string(member)?);
 2063   2063   
                }
 2064   2064   
                _ => {}
 2065   2065   
            }
 2066   2066   
            Ok(())
 2067   2067   
        })?;
 2068   2068   
        Ok(builder.build())
 2069   2069   
    }
 2070   2070   
}
        2071  +
impl Error {
        2072  +
    /// Deserializes this structure from a body deserializer and HTTP response.
        2073  +
    pub fn deserialize_with_response(
        2074  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
        2075  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
        2076  +
        _status: u16,
        2077  +
        _body: &[u8],
        2078  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
        2079  +
        Self::deserialize(deserializer)
        2080  +
    }
        2081  +
}
 2071   2082   
impl Error {
 2072   2083   
    /// Creates a new builder-style object to manufacture [`Error`](crate::types::Error).
 2073   2084   
    pub fn builder() -> crate::types::builders::ErrorBuilder {
 2074   2085   
        crate::types::builders::ErrorBuilder::default()
 2075   2086   
    }
 2076   2087   
}
 2077   2088   
 2078   2089   
/// A builder for [`Error`](crate::types::Error).
 2079   2090   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 2080   2091   
#[non_exhaustive]

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

@@ -131,131 +252,263 @@
  151    151   
    /// </ul>
  152    152   
    pub fn error_message(&self) -> ::std::option::Option<&str> {
  153    153   
        self.error_message.as_deref()
  154    154   
    }
  155    155   
}
  156    156   
static ERRORDETAILS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  157    157   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ErrorDetails", "com.amazonaws.s3", "ErrorDetails");
  158    158   
static ERRORDETAILS_MEMBER_ERROR_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  159    159   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ErrorDetails$ErrorCode", "com.amazonaws.s3", "ErrorDetails"),
  160    160   
    ::aws_smithy_schema::ShapeType::String,
  161         -
    "error_code",
         161  +
    "ErrorCode",
  162    162   
    0,
  163    163   
);
  164    164   
static ERRORDETAILS_MEMBER_ERROR_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  165    165   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ErrorDetails$ErrorMessage", "com.amazonaws.s3", "ErrorDetails"),
  166    166   
    ::aws_smithy_schema::ShapeType::String,
  167         -
    "error_message",
         167  +
    "ErrorMessage",
  168    168   
    1,
  169    169   
);
  170    170   
static ERRORDETAILS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  171    171   
    ERRORDETAILS_SCHEMA_ID,
  172    172   
    ::aws_smithy_schema::ShapeType::Structure,
  173    173   
    &[&ERRORDETAILS_MEMBER_ERROR_CODE, &ERRORDETAILS_MEMBER_ERROR_MESSAGE],
  174    174   
);
  175    175   
impl ErrorDetails {
  176    176   
    /// The schema for this shape.
  177    177   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ERRORDETAILS_SCHEMA;
  178    178   
}
  179    179   
impl ::aws_smithy_schema::serde::SerializableStruct for ErrorDetails {
  180    180   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  181    181   
    fn serialize_members(
  182    182   
        &self,
  183    183   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  184    184   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  185    185   
        if let Some(ref val) = self.error_code {
  186    186   
            ser.write_string(&ERRORDETAILS_MEMBER_ERROR_CODE, val)?;
  187    187   
        }
  188    188   
        if let Some(ref val) = self.error_message {
  189    189   
            ser.write_string(&ERRORDETAILS_MEMBER_ERROR_MESSAGE, val)?;
  190    190   
        }
  191    191   
        Ok(())
  192    192   
    }
  193    193   
}
  194    194   
impl ErrorDetails {
  195    195   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  196         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  197         -
        deserializer: &mut D,
         196  +
    pub fn deserialize(
         197  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  198    198   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  199    199   
        #[allow(unused_variables, unused_mut)]
  200    200   
        let mut builder = Self::builder();
  201    201   
        #[allow(
  202    202   
            unused_variables,
  203    203   
            unreachable_code,
  204    204   
            clippy::single_match,
  205    205   
            clippy::match_single_binding,
  206    206   
            clippy::diverging_sub_expression
  207    207   
        )]
  208         -
        deserializer.read_struct(&ERRORDETAILS_SCHEMA, (), |_, member, deser| {
         208  +
        deserializer.read_struct(&ERRORDETAILS_SCHEMA, &mut |member, deser| {
  209    209   
            match member.member_index() {
  210    210   
                Some(0) => {
  211    211   
                    builder.error_code = Some(deser.read_string(member)?);
  212    212   
                }
  213    213   
                Some(1) => {
  214    214   
                    builder.error_message = Some(deser.read_string(member)?);
  215    215   
                }
  216    216   
                _ => {}
  217    217   
            }
  218    218   
            Ok(())
  219    219   
        })?;
  220    220   
        Ok(builder.build())
  221    221   
    }
  222    222   
}
         223  +
impl ErrorDetails {
         224  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         225  +
    pub fn deserialize_with_response(
         226  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         227  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         228  +
        _status: u16,
         229  +
        _body: &[u8],
         230  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         231  +
        Self::deserialize(deserializer)
         232  +
    }
         233  +
}
  223    234   
impl ErrorDetails {
  224    235   
    /// Creates a new builder-style object to manufacture [`ErrorDetails`](crate::types::ErrorDetails).
  225    236   
    pub fn builder() -> crate::types::builders::ErrorDetailsBuilder {
  226    237   
        crate::types::builders::ErrorDetailsBuilder::default()
  227    238   
    }
  228    239   
}
  229    240   
  230    241   
/// A builder for [`ErrorDetails`](crate::types::ErrorDetails).
  231    242   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  232    243   
#[non_exhaustive]

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

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

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

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

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

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

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

@@ -1,1 +118,129 @@
   17     17   
    /// <p>The value that the filter searches for in object key names.</p>
   18     18   
    pub fn value(&self) -> ::std::option::Option<&str> {
   19     19   
        self.value.as_deref()
   20     20   
    }
   21     21   
}
   22     22   
static FILTERRULE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#FilterRule", "com.amazonaws.s3", "FilterRule");
   24     24   
static FILTERRULE_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#FilterRule$Name", "com.amazonaws.s3", "FilterRule"),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "name",
          27  +
    "Name",
   28     28   
    0,
   29     29   
);
   30     30   
static FILTERRULE_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#FilterRule$Value", "com.amazonaws.s3", "FilterRule"),
   32     32   
    ::aws_smithy_schema::ShapeType::String,
   33         -
    "value",
          33  +
    "Value",
   34     34   
    1,
   35     35   
);
   36     36   
static FILTERRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   37     37   
    FILTERRULE_SCHEMA_ID,
   38     38   
    ::aws_smithy_schema::ShapeType::Structure,
   39     39   
    &[&FILTERRULE_MEMBER_NAME, &FILTERRULE_MEMBER_VALUE],
   40     40   
);
   41     41   
impl FilterRule {
   42     42   
    /// The schema for this shape.
   43     43   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FILTERRULE_SCHEMA;
   44     44   
}
   45     45   
impl ::aws_smithy_schema::serde::SerializableStruct for FilterRule {
   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.name {
   52     52   
            ser.write_string(&FILTERRULE_MEMBER_NAME, val.as_str())?;
   53     53   
        }
   54     54   
        if let Some(ref val) = self.value {
   55     55   
            ser.write_string(&FILTERRULE_MEMBER_VALUE, val)?;
   56     56   
        }
   57     57   
        Ok(())
   58     58   
    }
   59     59   
}
   60     60   
impl FilterRule {
   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(&FILTERRULE_SCHEMA, (), |_, member, deser| {
          74  +
        deserializer.read_struct(&FILTERRULE_SCHEMA, &mut |member, deser| {
   75     75   
            match member.member_index() {
   76     76   
                Some(0) => {
   77     77   
                    builder.name = Some(crate::types::FilterRuleName::from(deser.read_string(member)?.as_str()));
   78     78   
                }
   79     79   
                Some(1) => {
   80     80   
                    builder.value = 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 FilterRule {
          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 FilterRule {
   90    101   
    /// Creates a new builder-style object to manufacture [`FilterRule`](crate::types::FilterRule).
   91    102   
    pub fn builder() -> crate::types::builders::FilterRuleBuilder {
   92    103   
        crate::types::builders::FilterRuleBuilder::default()
   93    104   
    }
   94    105   
}
   95    106   
   96    107   
/// A builder for [`FilterRule`](crate::types::FilterRule).
   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/_get_bucket_metadata_configuration_result.rs

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

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

@@ -30,30 +178,190 @@
   50     50   
    "GetBucketMetadataTableConfigurationResult",
   51     51   
);
   52     52   
static GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_METADATA_TABLE_CONFIGURATION_RESULT: ::aws_smithy_schema::Schema =
   53     53   
    ::aws_smithy_schema::Schema::new_member(
   54     54   
        ::aws_smithy_schema::ShapeId::from_static(
   55     55   
            "com.amazonaws.s3#GetBucketMetadataTableConfigurationResult$MetadataTableConfigurationResult",
   56     56   
            "com.amazonaws.s3",
   57     57   
            "GetBucketMetadataTableConfigurationResult",
   58     58   
        ),
   59     59   
        ::aws_smithy_schema::ShapeType::Structure,
   60         -
        "metadata_table_configuration_result",
          60  +
        "MetadataTableConfigurationResult",
   61     61   
        0,
   62     62   
    );
   63     63   
static GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.s3#GetBucketMetadataTableConfigurationResult$Status",
   66     66   
        "com.amazonaws.s3",
   67     67   
        "GetBucketMetadataTableConfigurationResult",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "status",
          70  +
    "Status",
   71     71   
    1,
   72     72   
);
   73     73   
static GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_ERROR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.s3#GetBucketMetadataTableConfigurationResult$Error",
   76     76   
        "com.amazonaws.s3",
   77     77   
        "GetBucketMetadataTableConfigurationResult",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::Structure,
   80         -
    "error",
          80  +
    "Error",
   81     81   
    2,
   82     82   
);
   83     83   
static GETBUCKETMETADATATABLECONFIGURATIONRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   84     84   
    GETBUCKETMETADATATABLECONFIGURATIONRESULT_SCHEMA_ID,
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86     86   
    &[
   87     87   
        &GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_METADATA_TABLE_CONFIGURATION_RESULT,
   88     88   
        &GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_STATUS,
   89     89   
        &GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_ERROR,
   90     90   
    ],
   91     91   
);
   92     92   
impl GetBucketMetadataTableConfigurationResult {
   93     93   
    /// The schema for this shape.
   94     94   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETBUCKETMETADATATABLECONFIGURATIONRESULT_SCHEMA;
   95     95   
}
   96     96   
impl ::aws_smithy_schema::serde::SerializableStruct for GetBucketMetadataTableConfigurationResult {
   97     97   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   98     98   
    fn serialize_members(
   99     99   
        &self,
  100    100   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  101    101   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  102    102   
        if let Some(ref val) = self.metadata_table_configuration_result {
  103    103   
            ser.write_struct(&GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_METADATA_TABLE_CONFIGURATION_RESULT, val)?;
  104    104   
        }
  105    105   
        {
  106    106   
            let val = &self.status;
  107    107   
            ser.write_string(&GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_STATUS, val)?;
  108    108   
        }
  109    109   
        if let Some(ref val) = self.error {
  110    110   
            ser.write_struct(&GETBUCKETMETADATATABLECONFIGURATIONRESULT_MEMBER_ERROR, val)?;
  111    111   
        }
  112    112   
        Ok(())
  113    113   
    }
  114    114   
}
  115    115   
impl GetBucketMetadataTableConfigurationResult {
  116    116   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  117         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  118         -
        deserializer: &mut D,
         117  +
    pub fn deserialize(
         118  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  119    119   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  120    120   
        #[allow(unused_variables, unused_mut)]
  121    121   
        let mut builder = Self::builder();
  122    122   
        #[allow(
  123    123   
            unused_variables,
  124    124   
            unreachable_code,
  125    125   
            clippy::single_match,
  126    126   
            clippy::match_single_binding,
  127    127   
            clippy::diverging_sub_expression
  128    128   
        )]
  129         -
        deserializer.read_struct(&GETBUCKETMETADATATABLECONFIGURATIONRESULT_SCHEMA, (), |_, member, deser| {
         129  +
        deserializer.read_struct(&GETBUCKETMETADATATABLECONFIGURATIONRESULT_SCHEMA, &mut |member, deser| {
  130    130   
            match member.member_index() {
  131    131   
                Some(0) => {
  132    132   
                    builder.metadata_table_configuration_result = Some(crate::types::MetadataTableConfigurationResult::deserialize(deser)?);
  133    133   
                }
  134    134   
                Some(1) => {
  135    135   
                    builder.status = Some(deser.read_string(member)?);
  136    136   
                }
  137    137   
                Some(2) => {
  138    138   
                    builder.error = Some(crate::types::ErrorDetails::deserialize(deser)?);
  139    139   
                }
  140    140   
                _ => {}
  141    141   
            }
  142    142   
            Ok(())
  143    143   
        })?;
         144  +
        builder.status = builder.status.or(Some(String::new()));
  144    145   
        builder
  145    146   
            .build()
  146    147   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  147    148   
    }
  148    149   
}
         150  +
impl GetBucketMetadataTableConfigurationResult {
         151  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         152  +
    pub fn deserialize_with_response(
         153  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         154  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         155  +
        _status: u16,
         156  +
        _body: &[u8],
         157  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         158  +
        Self::deserialize(deserializer)
         159  +
    }
         160  +
}
  149    161   
impl GetBucketMetadataTableConfigurationResult {
  150    162   
    /// Creates a new builder-style object to manufacture [`GetBucketMetadataTableConfigurationResult`](crate::types::GetBucketMetadataTableConfigurationResult).
  151    163   
    pub fn builder() -> crate::types::builders::GetBucketMetadataTableConfigurationResultBuilder {
  152    164   
        crate::types::builders::GetBucketMetadataTableConfigurationResultBuilder::default()
  153    165   
    }
  154    166   
}
  155    167   
  156    168   
/// A builder for [`GetBucketMetadataTableConfigurationResult`](crate::types::GetBucketMetadataTableConfigurationResult).
  157    169   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  158    170   
#[non_exhaustive]

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

@@ -44,44 +261,269 @@
   64     64   
    "com.amazonaws.s3",
   65     65   
    "GetObjectAttributesParts",
   66     66   
);
   67     67   
static GETOBJECTATTRIBUTESPARTS_MEMBER_TOTAL_PARTS_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.s3#GetObjectAttributesParts$TotalPartsCount",
   70     70   
        "com.amazonaws.s3",
   71     71   
        "GetObjectAttributesParts",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::Integer,
   74         -
    "total_parts_count",
          74  +
    "TotalPartsCount",
   75     75   
    0,
   76     76   
)
   77     77   
.with_xml_name("PartsCount");
   78     78   
static GETOBJECTATTRIBUTESPARTS_MEMBER_PART_NUMBER_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.s3#GetObjectAttributesParts$PartNumberMarker",
   81     81   
        "com.amazonaws.s3",
   82     82   
        "GetObjectAttributesParts",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::String,
   85         -
    "part_number_marker",
          85  +
    "PartNumberMarker",
   86     86   
    1,
   87     87   
);
   88     88   
static GETOBJECTATTRIBUTESPARTS_MEMBER_NEXT_PART_NUMBER_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.s3#GetObjectAttributesParts$NextPartNumberMarker",
   91     91   
        "com.amazonaws.s3",
   92     92   
        "GetObjectAttributesParts",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::String,
   95         -
    "next_part_number_marker",
          95  +
    "NextPartNumberMarker",
   96     96   
    2,
   97     97   
);
   98     98   
static GETOBJECTATTRIBUTESPARTS_MEMBER_MAX_PARTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static(
  100    100   
        "com.amazonaws.s3#GetObjectAttributesParts$MaxParts",
  101    101   
        "com.amazonaws.s3",
  102    102   
        "GetObjectAttributesParts",
  103    103   
    ),
  104    104   
    ::aws_smithy_schema::ShapeType::Integer,
  105         -
    "max_parts",
         105  +
    "MaxParts",
  106    106   
    3,
  107    107   
);
  108    108   
static GETOBJECTATTRIBUTESPARTS_MEMBER_IS_TRUNCATED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static(
  110    110   
        "com.amazonaws.s3#GetObjectAttributesParts$IsTruncated",
  111    111   
        "com.amazonaws.s3",
  112    112   
        "GetObjectAttributesParts",
  113    113   
    ),
  114    114   
    ::aws_smithy_schema::ShapeType::Boolean,
  115         -
    "is_truncated",
         115  +
    "IsTruncated",
  116    116   
    4,
  117    117   
);
  118    118   
static GETOBJECTATTRIBUTESPARTS_MEMBER_PARTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.s3#GetObjectAttributesParts$Parts",
  121    121   
        "com.amazonaws.s3",
  122    122   
        "GetObjectAttributesParts",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::List,
  125         -
    "parts",
         125  +
    "Parts",
  126    126   
    5,
  127    127   
)
  128    128   
.with_xml_name("Part")
  129    129   
.with_xml_flattened();
  130    130   
static GETOBJECTATTRIBUTESPARTS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  131    131   
    GETOBJECTATTRIBUTESPARTS_SCHEMA_ID,
  132    132   
    ::aws_smithy_schema::ShapeType::Structure,
  133    133   
    &[
  134    134   
        &GETOBJECTATTRIBUTESPARTS_MEMBER_TOTAL_PARTS_COUNT,
  135    135   
        &GETOBJECTATTRIBUTESPARTS_MEMBER_PART_NUMBER_MARKER,
  136    136   
        &GETOBJECTATTRIBUTESPARTS_MEMBER_NEXT_PART_NUMBER_MARKER,
  137    137   
        &GETOBJECTATTRIBUTESPARTS_MEMBER_MAX_PARTS,
  138    138   
        &GETOBJECTATTRIBUTESPARTS_MEMBER_IS_TRUNCATED,
  139    139   
        &GETOBJECTATTRIBUTESPARTS_MEMBER_PARTS,
  140    140   
    ],
  141    141   
);
  142    142   
impl GetObjectAttributesParts {
  143    143   
    /// The schema for this shape.
  144    144   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETOBJECTATTRIBUTESPARTS_SCHEMA;
  145    145   
}
  146    146   
impl ::aws_smithy_schema::serde::SerializableStruct for GetObjectAttributesParts {
  147    147   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  148    148   
    fn serialize_members(
  149    149   
        &self,
  150    150   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  151    151   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  152    152   
        if let Some(ref val) = self.total_parts_count {
  153    153   
            ser.write_integer(&GETOBJECTATTRIBUTESPARTS_MEMBER_TOTAL_PARTS_COUNT, *val)?;
  154    154   
        }
  155    155   
        if let Some(ref val) = self.part_number_marker {
  156    156   
            ser.write_string(&GETOBJECTATTRIBUTESPARTS_MEMBER_PART_NUMBER_MARKER, val)?;
  157    157   
        }
  158    158   
        if let Some(ref val) = self.next_part_number_marker {
  159    159   
            ser.write_string(&GETOBJECTATTRIBUTESPARTS_MEMBER_NEXT_PART_NUMBER_MARKER, val)?;
  160    160   
        }
  161    161   
        if let Some(ref val) = self.max_parts {
  162    162   
            ser.write_integer(&GETOBJECTATTRIBUTESPARTS_MEMBER_MAX_PARTS, *val)?;
  163    163   
        }
  164    164   
        if let Some(ref val) = self.is_truncated {
  165    165   
            ser.write_boolean(&GETOBJECTATTRIBUTESPARTS_MEMBER_IS_TRUNCATED, *val)?;
  166    166   
        }
  167    167   
        if let Some(ref val) = self.parts {
  168    168   
            ser.write_list(
  169    169   
                &GETOBJECTATTRIBUTESPARTS_MEMBER_PARTS,
  170    170   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  171    171   
                    for item in val {
  172    172   
                        ser.write_struct(crate::types::ObjectPart::SCHEMA, item)?;
  173    173   
                    }
  174    174   
                    Ok(())
  175    175   
                },
  176    176   
            )?;
  177    177   
        }
  178    178   
        Ok(())
  179    179   
    }
  180    180   
}
  181    181   
impl GetObjectAttributesParts {
  182    182   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  183         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  184         -
        deserializer: &mut D,
         183  +
    pub fn deserialize(
         184  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  185    185   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  186    186   
        #[allow(unused_variables, unused_mut)]
  187    187   
        let mut builder = Self::builder();
  188    188   
        #[allow(
  189    189   
            unused_variables,
  190    190   
            unreachable_code,
  191    191   
            clippy::single_match,
  192    192   
            clippy::match_single_binding,
  193    193   
            clippy::diverging_sub_expression
  194    194   
        )]
  195         -
        deserializer.read_struct(&GETOBJECTATTRIBUTESPARTS_SCHEMA, (), |_, member, deser| {
         195  +
        deserializer.read_struct(&GETOBJECTATTRIBUTESPARTS_SCHEMA, &mut |member, deser| {
  196    196   
            match member.member_index() {
  197    197   
                Some(0) => {
  198    198   
                    builder.total_parts_count = Some(deser.read_integer(member)?);
  199    199   
                }
  200    200   
                Some(1) => {
  201    201   
                    builder.part_number_marker = Some(deser.read_string(member)?);
  202    202   
                }
  203    203   
                Some(2) => {
  204    204   
                    builder.next_part_number_marker = Some(deser.read_string(member)?);
  205    205   
                }
  206    206   
                Some(3) => {
  207    207   
                    builder.max_parts = Some(deser.read_integer(member)?);
  208    208   
                }
  209    209   
                Some(4) => {
  210    210   
                    builder.is_truncated = Some(deser.read_boolean(member)?);
  211    211   
                }
  212    212   
                Some(5) => {
  213    213   
                    builder.parts = Some({
  214         -
                        let container = if let Some(cap) = deser.container_size() {
  215         -
                            Vec::with_capacity(cap)
  216         -
                        } else {
  217         -
                            Vec::new()
  218         -
                        };
  219         -
                        deser.read_list(member, container, |mut list, deser| {
  220         -
                            list.push(crate::types::ObjectPart::deserialize(deser)?);
  221         -
                            Ok(list)
  222         -
                        })?
         214  +
                        let mut container = Vec::new();
         215  +
                        deser.read_list(member, &mut |deser| {
         216  +
                            container.push(crate::types::ObjectPart::deserialize(deser)?);
         217  +
                            Ok(())
         218  +
                        })?;
         219  +
                        container
  223    220   
                    });
  224    221   
                }
  225    222   
                _ => {}
  226    223   
            }
  227    224   
            Ok(())
  228    225   
        })?;
  229    226   
        Ok(builder.build())
  230    227   
    }
  231    228   
}
         229  +
impl GetObjectAttributesParts {
         230  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         231  +
    pub fn deserialize_with_response(
         232  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         233  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         234  +
        _status: u16,
         235  +
        _body: &[u8],
         236  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         237  +
        Self::deserialize(deserializer)
         238  +
    }
         239  +
}
  232    240   
impl GetObjectAttributesParts {
  233    241   
    /// Creates a new builder-style object to manufacture [`GetObjectAttributesParts`](crate::types::GetObjectAttributesParts).
  234    242   
    pub fn builder() -> crate::types::builders::GetObjectAttributesPartsBuilder {
  235    243   
        crate::types::builders::GetObjectAttributesPartsBuilder::default()
  236    244   
    }
  237    245   
}
  238    246   
  239    247   
/// A builder for [`GetObjectAttributesParts`](crate::types::GetObjectAttributesParts).
  240    248   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  241    249   
#[non_exhaustive]