AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045 (ignoring whitespace)

Files changed:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -57,57 +287,298 @@
   77     77   
    /// </note>
   78     78   
    pub fn delete_marker_replication(&self) -> ::std::option::Option<&crate::types::DeleteMarkerReplication> {
   79     79   
        self.delete_marker_replication.as_ref()
   80     80   
    }
   81     81   
}
   82     82   
static REPLICATIONRULE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   83     83   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ReplicationRule", "com.amazonaws.s3", "ReplicationRule");
   84     84   
static REPLICATIONRULE_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ReplicationRule$ID", "com.amazonaws.s3", "ReplicationRule"),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "id",
          87  +
    "ID",
   88     88   
    0,
   89     89   
);
   90     90   
static REPLICATIONRULE_MEMBER_PRIORITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ReplicationRule$Priority", "com.amazonaws.s3", "ReplicationRule"),
   92     92   
    ::aws_smithy_schema::ShapeType::Integer,
   93         -
    "priority",
          93  +
    "Priority",
   94     94   
    1,
   95     95   
);
   96     96   
static REPLICATIONRULE_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ReplicationRule$Prefix", "com.amazonaws.s3", "ReplicationRule"),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "prefix",
          99  +
    "Prefix",
  100    100   
    2,
  101    101   
);
  102    102   
static REPLICATIONRULE_MEMBER_FILTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ReplicationRule$Filter", "com.amazonaws.s3", "ReplicationRule"),
  104    104   
    ::aws_smithy_schema::ShapeType::Structure,
  105         -
    "filter",
         105  +
    "Filter",
  106    106   
    3,
  107    107   
);
  108    108   
static REPLICATIONRULE_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ReplicationRule$Status", "com.amazonaws.s3", "ReplicationRule"),
  110    110   
    ::aws_smithy_schema::ShapeType::String,
  111         -
    "status",
         111  +
    "Status",
  112    112   
    4,
  113    113   
);
  114    114   
static REPLICATIONRULE_MEMBER_SOURCE_SELECTION_CRITERIA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "com.amazonaws.s3#ReplicationRule$SourceSelectionCriteria",
  117    117   
        "com.amazonaws.s3",
  118    118   
        "ReplicationRule",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::Structure,
  121         -
    "source_selection_criteria",
         121  +
    "SourceSelectionCriteria",
  122    122   
    5,
  123    123   
);
  124    124   
static REPLICATIONRULE_MEMBER_EXISTING_OBJECT_REPLICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static(
  126    126   
        "com.amazonaws.s3#ReplicationRule$ExistingObjectReplication",
  127    127   
        "com.amazonaws.s3",
  128    128   
        "ReplicationRule",
  129    129   
    ),
  130    130   
    ::aws_smithy_schema::ShapeType::Structure,
  131         -
    "existing_object_replication",
         131  +
    "ExistingObjectReplication",
  132    132   
    6,
  133    133   
);
  134    134   
static REPLICATIONRULE_MEMBER_DESTINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ReplicationRule$Destination", "com.amazonaws.s3", "ReplicationRule"),
  136    136   
    ::aws_smithy_schema::ShapeType::Structure,
  137         -
    "destination",
         137  +
    "Destination",
  138    138   
    7,
  139    139   
);
  140    140   
static REPLICATIONRULE_MEMBER_DELETE_MARKER_REPLICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static(
  142    142   
        "com.amazonaws.s3#ReplicationRule$DeleteMarkerReplication",
  143    143   
        "com.amazonaws.s3",
  144    144   
        "ReplicationRule",
  145    145   
    ),
  146    146   
    ::aws_smithy_schema::ShapeType::Structure,
  147         -
    "delete_marker_replication",
         147  +
    "DeleteMarkerReplication",
  148    148   
    8,
  149    149   
);
  150    150   
static REPLICATIONRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  151    151   
    REPLICATIONRULE_SCHEMA_ID,
  152    152   
    ::aws_smithy_schema::ShapeType::Structure,
  153    153   
    &[
  154    154   
        &REPLICATIONRULE_MEMBER_ID,
  155    155   
        &REPLICATIONRULE_MEMBER_PRIORITY,
  156    156   
        &REPLICATIONRULE_MEMBER_PREFIX,
  157    157   
        &REPLICATIONRULE_MEMBER_FILTER,
  158    158   
        &REPLICATIONRULE_MEMBER_STATUS,
  159    159   
        &REPLICATIONRULE_MEMBER_SOURCE_SELECTION_CRITERIA,
  160    160   
        &REPLICATIONRULE_MEMBER_EXISTING_OBJECT_REPLICATION,
  161    161   
        &REPLICATIONRULE_MEMBER_DESTINATION,
  162    162   
        &REPLICATIONRULE_MEMBER_DELETE_MARKER_REPLICATION,
  163    163   
    ],
  164    164   
);
  165    165   
impl ReplicationRule {
  166    166   
    /// The schema for this shape.
  167    167   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REPLICATIONRULE_SCHEMA;
  168    168   
}
  169    169   
impl ::aws_smithy_schema::serde::SerializableStruct for ReplicationRule {
  170    170   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  171    171   
    fn serialize_members(
  172    172   
        &self,
  173    173   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  174    174   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  175    175   
        if let Some(ref val) = self.id {
  176    176   
            ser.write_string(&REPLICATIONRULE_MEMBER_ID, val)?;
  177    177   
        }
  178    178   
        if let Some(ref val) = self.priority {
  179    179   
            ser.write_integer(&REPLICATIONRULE_MEMBER_PRIORITY, *val)?;
  180    180   
        }
  181    181   
        if let Some(ref val) = self.prefix {
  182    182   
            ser.write_string(&REPLICATIONRULE_MEMBER_PREFIX, val)?;
  183    183   
        }
  184    184   
        if let Some(ref val) = self.filter {
  185    185   
            ser.write_struct(&REPLICATIONRULE_MEMBER_FILTER, val)?;
  186    186   
        }
  187    187   
        {
  188    188   
            let val = &self.status;
  189    189   
            ser.write_string(&REPLICATIONRULE_MEMBER_STATUS, val.as_str())?;
  190    190   
        }
  191    191   
        if let Some(ref val) = self.source_selection_criteria {
  192    192   
            ser.write_struct(&REPLICATIONRULE_MEMBER_SOURCE_SELECTION_CRITERIA, val)?;
  193    193   
        }
  194    194   
        if let Some(ref val) = self.existing_object_replication {
  195    195   
            ser.write_struct(&REPLICATIONRULE_MEMBER_EXISTING_OBJECT_REPLICATION, val)?;
  196    196   
        }
  197    197   
        if let Some(ref val) = self.destination {
  198    198   
            ser.write_struct(&REPLICATIONRULE_MEMBER_DESTINATION, val)?;
  199    199   
        }
  200    200   
        if let Some(ref val) = self.delete_marker_replication {
  201    201   
            ser.write_struct(&REPLICATIONRULE_MEMBER_DELETE_MARKER_REPLICATION, val)?;
  202    202   
        }
  203    203   
        Ok(())
  204    204   
    }
  205    205   
}
  206    206   
impl ReplicationRule {
  207    207   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  208         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  209         -
        deserializer: &mut D,
         208  +
    pub fn deserialize(
         209  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  210    210   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  211    211   
        #[allow(unused_variables, unused_mut)]
  212    212   
        let mut builder = Self::builder();
  213    213   
        #[allow(
  214    214   
            unused_variables,
  215    215   
            unreachable_code,
  216    216   
            clippy::single_match,
  217    217   
            clippy::match_single_binding,
  218    218   
            clippy::diverging_sub_expression
  219    219   
        )]
  220         -
        deserializer.read_struct(&REPLICATIONRULE_SCHEMA, (), |_, member, deser| {
         220  +
        deserializer.read_struct(&REPLICATIONRULE_SCHEMA, &mut |member, deser| {
  221    221   
            match member.member_index() {
  222    222   
                Some(0) => {
  223    223   
                    builder.id = Some(deser.read_string(member)?);
  224    224   
                }
  225    225   
                Some(1) => {
  226    226   
                    builder.priority = Some(deser.read_integer(member)?);
  227    227   
                }
  228    228   
                Some(2) => {
  229    229   
                    builder.prefix = Some(deser.read_string(member)?);
  230    230   
                }
  231    231   
                Some(3) => {
  232    232   
                    builder.filter = Some(crate::types::ReplicationRuleFilter::deserialize(deser)?);
  233    233   
                }
  234    234   
                Some(4) => {
  235    235   
                    builder.status = Some(crate::types::ReplicationRuleStatus::from(deser.read_string(member)?.as_str()));
  236    236   
                }
  237    237   
                Some(5) => {
  238    238   
                    builder.source_selection_criteria = Some(crate::types::SourceSelectionCriteria::deserialize(deser)?);
  239    239   
                }
  240    240   
                Some(6) => {
  241    241   
                    builder.existing_object_replication = Some(crate::types::ExistingObjectReplication::deserialize(deser)?);
  242    242   
                }
  243    243   
                Some(7) => {
  244    244   
                    builder.destination = Some(crate::types::Destination::deserialize(deser)?);
  245    245   
                }
  246    246   
                Some(8) => {
  247    247   
                    builder.delete_marker_replication = Some(crate::types::DeleteMarkerReplication::deserialize(deser)?);
  248    248   
                }
  249    249   
                _ => {}
  250    250   
            }
  251    251   
            Ok(())
  252    252   
        })?;
  253    253   
        builder
  254    254   
            .build()
  255    255   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  256    256   
    }
  257    257   
}
         258  +
impl ReplicationRule {
         259  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         260  +
    pub fn deserialize_with_response(
         261  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         262  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         263  +
        _status: u16,
         264  +
        _body: &[u8],
         265  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         266  +
        Self::deserialize(deserializer)
         267  +
    }
         268  +
}
  258    269   
impl ReplicationRule {
  259    270   
    /// Creates a new builder-style object to manufacture [`ReplicationRule`](crate::types::ReplicationRule).
  260    271   
    pub fn builder() -> crate::types::builders::ReplicationRuleBuilder {
  261    272   
        crate::types::builders::ReplicationRuleBuilder::default()
  262    273   
    }
  263    274   
}
  264    275   
  265    276   
/// A builder for [`ReplicationRule`](crate::types::ReplicationRule).
  266    277   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  267    278   
#[non_exhaustive]

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

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

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

@@ -25,25 +162,173 @@
   45     45   
}
   46     46   
static REPLICATIONRULEFILTER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ReplicationRuleFilter", "com.amazonaws.s3", "ReplicationRuleFilter");
   48     48   
static REPLICATIONRULEFILTER_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static(
   50     50   
        "com.amazonaws.s3#ReplicationRuleFilter$Prefix",
   51     51   
        "com.amazonaws.s3",
   52     52   
        "ReplicationRuleFilter",
   53     53   
    ),
   54     54   
    ::aws_smithy_schema::ShapeType::String,
   55         -
    "prefix",
          55  +
    "Prefix",
   56     56   
    0,
   57     57   
);
   58     58   
static REPLICATIONRULEFILTER_MEMBER_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ReplicationRuleFilter$Tag", "com.amazonaws.s3", "ReplicationRuleFilter"),
   60     60   
    ::aws_smithy_schema::ShapeType::Structure,
   61         -
    "tag",
          61  +
    "Tag",
   62     62   
    1,
   63     63   
);
   64     64   
static REPLICATIONRULEFILTER_MEMBER_AND: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ReplicationRuleFilter$And", "com.amazonaws.s3", "ReplicationRuleFilter"),
   66     66   
    ::aws_smithy_schema::ShapeType::Structure,
   67         -
    "and",
          67  +
    "And",
   68     68   
    2,
   69     69   
);
   70     70   
static REPLICATIONRULEFILTER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   71     71   
    REPLICATIONRULEFILTER_SCHEMA_ID,
   72     72   
    ::aws_smithy_schema::ShapeType::Structure,
   73     73   
    &[
   74     74   
        &REPLICATIONRULEFILTER_MEMBER_PREFIX,
   75     75   
        &REPLICATIONRULEFILTER_MEMBER_TAG,
   76     76   
        &REPLICATIONRULEFILTER_MEMBER_AND,
   77     77   
    ],
   78     78   
);
   79     79   
impl ReplicationRuleFilter {
   80     80   
    /// The schema for this shape.
   81     81   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REPLICATIONRULEFILTER_SCHEMA;
   82     82   
}
   83     83   
impl ::aws_smithy_schema::serde::SerializableStruct for ReplicationRuleFilter {
   84     84   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   85     85   
    fn serialize_members(
   86     86   
        &self,
   87     87   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   88     88   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   89     89   
        if let Some(ref val) = self.prefix {
   90     90   
            ser.write_string(&REPLICATIONRULEFILTER_MEMBER_PREFIX, val)?;
   91     91   
        }
   92     92   
        if let Some(ref val) = self.tag {
   93     93   
            ser.write_struct(&REPLICATIONRULEFILTER_MEMBER_TAG, val)?;
   94     94   
        }
   95     95   
        if let Some(ref val) = self.and {
   96     96   
            ser.write_struct(&REPLICATIONRULEFILTER_MEMBER_AND, val)?;
   97     97   
        }
   98     98   
        Ok(())
   99     99   
    }
  100    100   
}
  101    101   
impl ReplicationRuleFilter {
  102    102   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  103         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  104         -
        deserializer: &mut D,
         103  +
    pub fn deserialize(
         104  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  105    105   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  106    106   
        #[allow(unused_variables, unused_mut)]
  107    107   
        let mut builder = Self::builder();
  108    108   
        #[allow(
  109    109   
            unused_variables,
  110    110   
            unreachable_code,
  111    111   
            clippy::single_match,
  112    112   
            clippy::match_single_binding,
  113    113   
            clippy::diverging_sub_expression
  114    114   
        )]
  115         -
        deserializer.read_struct(&REPLICATIONRULEFILTER_SCHEMA, (), |_, member, deser| {
         115  +
        deserializer.read_struct(&REPLICATIONRULEFILTER_SCHEMA, &mut |member, deser| {
  116    116   
            match member.member_index() {
  117    117   
                Some(0) => {
  118    118   
                    builder.prefix = Some(deser.read_string(member)?);
  119    119   
                }
  120    120   
                Some(1) => {
  121    121   
                    builder.tag = Some(crate::types::Tag::deserialize(deser)?);
  122    122   
                }
  123    123   
                Some(2) => {
  124    124   
                    builder.and = Some(crate::types::ReplicationRuleAndOperator::deserialize(deser)?);
  125    125   
                }
  126    126   
                _ => {}
  127    127   
            }
  128    128   
            Ok(())
  129    129   
        })?;
  130    130   
        Ok(builder.build())
  131    131   
    }
  132    132   
}
         133  +
impl ReplicationRuleFilter {
         134  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         135  +
    pub fn deserialize_with_response(
         136  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         137  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         138  +
        _status: u16,
         139  +
        _body: &[u8],
         140  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         141  +
        Self::deserialize(deserializer)
         142  +
    }
         143  +
}
  133    144   
impl ReplicationRuleFilter {
  134    145   
    /// Creates a new builder-style object to manufacture [`ReplicationRuleFilter`](crate::types::ReplicationRuleFilter).
  135    146   
    pub fn builder() -> crate::types::builders::ReplicationRuleFilterBuilder {
  136    147   
        crate::types::builders::ReplicationRuleFilterBuilder::default()
  137    148   
    }
  138    149   
}
  139    150   
  140    151   
/// A builder for [`ReplicationRuleFilter`](crate::types::ReplicationRuleFilter).
  141    152   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  142    153   
#[non_exhaustive]

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

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

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

@@ -1,1 +106,117 @@
   17     17   
}
   18     18   
static REPLICATIONTIMEVALUE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ReplicationTimeValue", "com.amazonaws.s3", "ReplicationTimeValue");
   20     20   
static REPLICATIONTIMEVALUE_MEMBER_MINUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   21     21   
    ::aws_smithy_schema::ShapeId::from_static(
   22     22   
        "com.amazonaws.s3#ReplicationTimeValue$Minutes",
   23     23   
        "com.amazonaws.s3",
   24     24   
        "ReplicationTimeValue",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::Integer,
   27         -
    "minutes",
          27  +
    "Minutes",
   28     28   
    0,
   29     29   
);
   30     30   
static REPLICATIONTIMEVALUE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   31     31   
    REPLICATIONTIMEVALUE_SCHEMA_ID,
   32     32   
    ::aws_smithy_schema::ShapeType::Structure,
   33     33   
    &[&REPLICATIONTIMEVALUE_MEMBER_MINUTES],
   34     34   
);
   35     35   
impl ReplicationTimeValue {
   36     36   
    /// The schema for this shape.
   37     37   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REPLICATIONTIMEVALUE_SCHEMA;
   38     38   
}
   39     39   
impl ::aws_smithy_schema::serde::SerializableStruct for ReplicationTimeValue {
   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.minutes {
   46     46   
            ser.write_integer(&REPLICATIONTIMEVALUE_MEMBER_MINUTES, *val)?;
   47     47   
        }
   48     48   
        Ok(())
   49     49   
    }
   50     50   
}
   51     51   
impl ReplicationTimeValue {
   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(&REPLICATIONTIMEVALUE_SCHEMA, (), |_, member, deser| {
          65  +
        deserializer.read_struct(&REPLICATIONTIMEVALUE_SCHEMA, &mut |member, deser| {
   66     66   
            match member.member_index() {
   67     67   
                Some(0) => {
   68     68   
                    builder.minutes = Some(deser.read_integer(member)?);
   69     69   
                }
   70     70   
                _ => {}
   71     71   
            }
   72     72   
            Ok(())
   73     73   
        })?;
   74     74   
        Ok(builder.build())
   75     75   
    }
   76     76   
}
          77  +
impl ReplicationTimeValue {
          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 ReplicationTimeValue {
   78     89   
    /// Creates a new builder-style object to manufacture [`ReplicationTimeValue`](crate::types::ReplicationTimeValue).
   79     90   
    pub fn builder() -> crate::types::builders::ReplicationTimeValueBuilder {
   80     91   
        crate::types::builders::ReplicationTimeValueBuilder::default()
   81     92   
    }
   82     93   
}
   83     94   
   84     95   
/// A builder for [`ReplicationTimeValue`](crate::types::ReplicationTimeValue).
   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/_request_payment_configuration.rs

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

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

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

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

@@ -41,41 +234,245 @@
   61     61   
    /// <p>Describes the location where the restore job's output is stored.</p>
   62     62   
    pub fn output_location(&self) -> ::std::option::Option<&crate::types::OutputLocation> {
   63     63   
        self.output_location.as_ref()
   64     64   
    }
   65     65   
}
   66     66   
static RESTOREREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#RestoreRequest", "com.amazonaws.s3", "RestoreRequest");
   68     68   
static RESTOREREQUEST_MEMBER_DAYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#RestoreRequest$Days", "com.amazonaws.s3", "RestoreRequest"),
   70     70   
    ::aws_smithy_schema::ShapeType::Integer,
   71         -
    "days",
          71  +
    "Days",
   72     72   
    0,
   73     73   
);
   74     74   
static RESTOREREQUEST_MEMBER_GLACIER_JOB_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "com.amazonaws.s3#RestoreRequest$GlacierJobParameters",
   77     77   
        "com.amazonaws.s3",
   78     78   
        "RestoreRequest",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::Structure,
   81         -
    "glacier_job_parameters",
          81  +
    "GlacierJobParameters",
   82     82   
    1,
   83     83   
);
   84     84   
static RESTOREREQUEST_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#RestoreRequest$Type", "com.amazonaws.s3", "RestoreRequest"),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "r##type",
          87  +
    "Type",
   88     88   
    2,
   89     89   
);
   90     90   
static RESTOREREQUEST_MEMBER_TIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#RestoreRequest$Tier", "com.amazonaws.s3", "RestoreRequest"),
   92     92   
    ::aws_smithy_schema::ShapeType::String,
   93         -
    "tier",
          93  +
    "Tier",
   94     94   
    3,
   95     95   
);
   96     96   
static RESTOREREQUEST_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#RestoreRequest$Description", "com.amazonaws.s3", "RestoreRequest"),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "description",
          99  +
    "Description",
  100    100   
    4,
  101    101   
);
  102    102   
static RESTOREREQUEST_MEMBER_SELECT_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#RestoreRequest$SelectParameters", "com.amazonaws.s3", "RestoreRequest"),
  104    104   
    ::aws_smithy_schema::ShapeType::Structure,
  105         -
    "select_parameters",
         105  +
    "SelectParameters",
  106    106   
    5,
  107    107   
);
  108    108   
static RESTOREREQUEST_MEMBER_OUTPUT_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#RestoreRequest$OutputLocation", "com.amazonaws.s3", "RestoreRequest"),
  110    110   
    ::aws_smithy_schema::ShapeType::Structure,
  111         -
    "output_location",
         111  +
    "OutputLocation",
  112    112   
    6,
  113    113   
);
  114    114   
static RESTOREREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  115    115   
    RESTOREREQUEST_SCHEMA_ID,
  116    116   
    ::aws_smithy_schema::ShapeType::Structure,
  117    117   
    &[
  118    118   
        &RESTOREREQUEST_MEMBER_DAYS,
  119    119   
        &RESTOREREQUEST_MEMBER_GLACIER_JOB_PARAMETERS,
  120    120   
        &RESTOREREQUEST_MEMBER_TYPE,
  121    121   
        &RESTOREREQUEST_MEMBER_TIER,
  122    122   
        &RESTOREREQUEST_MEMBER_DESCRIPTION,
  123    123   
        &RESTOREREQUEST_MEMBER_SELECT_PARAMETERS,
  124    124   
        &RESTOREREQUEST_MEMBER_OUTPUT_LOCATION,
  125    125   
    ],
  126    126   
);
  127    127   
impl RestoreRequest {
  128    128   
    /// The schema for this shape.
  129    129   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESTOREREQUEST_SCHEMA;
  130    130   
}
  131    131   
impl ::aws_smithy_schema::serde::SerializableStruct for RestoreRequest {
  132    132   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  133    133   
    fn serialize_members(
  134    134   
        &self,
  135    135   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  136    136   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  137    137   
        if let Some(ref val) = self.days {
  138    138   
            ser.write_integer(&RESTOREREQUEST_MEMBER_DAYS, *val)?;
  139    139   
        }
  140    140   
        if let Some(ref val) = self.glacier_job_parameters {
  141    141   
            ser.write_struct(&RESTOREREQUEST_MEMBER_GLACIER_JOB_PARAMETERS, val)?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.r#type {
  144    144   
            ser.write_string(&RESTOREREQUEST_MEMBER_TYPE, val.as_str())?;
  145    145   
        }
  146    146   
        if let Some(ref val) = self.tier {
  147    147   
            ser.write_string(&RESTOREREQUEST_MEMBER_TIER, val.as_str())?;
  148    148   
        }
  149    149   
        if let Some(ref val) = self.description {
  150    150   
            ser.write_string(&RESTOREREQUEST_MEMBER_DESCRIPTION, val)?;
  151    151   
        }
  152    152   
        if let Some(ref val) = self.select_parameters {
  153    153   
            ser.write_struct(&RESTOREREQUEST_MEMBER_SELECT_PARAMETERS, val)?;
  154    154   
        }
  155    155   
        if let Some(ref val) = self.output_location {
  156    156   
            ser.write_struct(&RESTOREREQUEST_MEMBER_OUTPUT_LOCATION, val)?;
  157    157   
        }
  158    158   
        Ok(())
  159    159   
    }
  160    160   
}
  161    161   
impl RestoreRequest {
  162    162   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  163         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  164         -
        deserializer: &mut D,
         163  +
    pub fn deserialize(
         164  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  165    165   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  166    166   
        #[allow(unused_variables, unused_mut)]
  167    167   
        let mut builder = Self::builder();
  168    168   
        #[allow(
  169    169   
            unused_variables,
  170    170   
            unreachable_code,
  171    171   
            clippy::single_match,
  172    172   
            clippy::match_single_binding,
  173    173   
            clippy::diverging_sub_expression
  174    174   
        )]
  175         -
        deserializer.read_struct(&RESTOREREQUEST_SCHEMA, (), |_, member, deser| {
         175  +
        deserializer.read_struct(&RESTOREREQUEST_SCHEMA, &mut |member, deser| {
  176    176   
            match member.member_index() {
  177    177   
                Some(0) => {
  178    178   
                    builder.days = Some(deser.read_integer(member)?);
  179    179   
                }
  180    180   
                Some(1) => {
  181    181   
                    builder.glacier_job_parameters = Some(crate::types::GlacierJobParameters::deserialize(deser)?);
  182    182   
                }
  183    183   
                Some(2) => {
  184    184   
                    builder.r#type = Some(crate::types::RestoreRequestType::from(deser.read_string(member)?.as_str()));
  185    185   
                }
  186    186   
                Some(3) => {
  187    187   
                    builder.tier = Some(crate::types::Tier::from(deser.read_string(member)?.as_str()));
  188    188   
                }
  189    189   
                Some(4) => {
  190    190   
                    builder.description = Some(deser.read_string(member)?);
  191    191   
                }
  192    192   
                Some(5) => {
  193    193   
                    builder.select_parameters = Some(crate::types::SelectParameters::deserialize(deser)?);
  194    194   
                }
  195    195   
                Some(6) => {
  196    196   
                    builder.output_location = Some(crate::types::OutputLocation::deserialize(deser)?);
  197    197   
                }
  198    198   
                _ => {}
  199    199   
            }
  200    200   
            Ok(())
  201    201   
        })?;
  202    202   
        Ok(builder.build())
  203    203   
    }
  204    204   
}
         205  +
impl RestoreRequest {
         206  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         207  +
    pub fn deserialize_with_response(
         208  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         209  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         210  +
        _status: u16,
         211  +
        _body: &[u8],
         212  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         213  +
        Self::deserialize(deserializer)
         214  +
    }
         215  +
}
  205    216   
impl RestoreRequest {
  206    217   
    /// Creates a new builder-style object to manufacture [`RestoreRequest`](crate::types::RestoreRequest).
  207    218   
    pub fn builder() -> crate::types::builders::RestoreRequestBuilder {
  208    219   
        crate::types::builders::RestoreRequestBuilder::default()
  209    220   
    }
  210    221   
}
  211    222   
  212    223   
/// A builder for [`RestoreRequest`](crate::types::RestoreRequest).
  213    224   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  214    225   
#[non_exhaustive]