AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36 (ignoring whitespace)

Files changed:

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

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

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

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

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

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

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

@@ -1,1 +121,132 @@
   17     17   
    /// <p>A container specifying the time threshold for emitting the <code>s3:Replication:OperationMissedThreshold</code> event.</p>
   18     18   
    pub fn event_threshold(&self) -> ::std::option::Option<&crate::types::ReplicationTimeValue> {
   19     19   
        self.event_threshold.as_ref()
   20     20   
    }
   21     21   
}
   22     22   
static METRICS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Metrics", "com.amazonaws.s3", "Metrics");
   24     24   
static METRICS_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Metrics$Status", "com.amazonaws.s3", "Metrics"),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "status",
          27  +
    "Status",
   28     28   
    0,
   29     29   
);
   30     30   
static METRICS_MEMBER_EVENT_THRESHOLD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Metrics$EventThreshold", "com.amazonaws.s3", "Metrics"),
   32     32   
    ::aws_smithy_schema::ShapeType::Structure,
   33         -
    "event_threshold",
          33  +
    "EventThreshold",
   34     34   
    1,
   35     35   
);
   36     36   
static METRICS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   37     37   
    METRICS_SCHEMA_ID,
   38     38   
    ::aws_smithy_schema::ShapeType::Structure,
   39     39   
    &[&METRICS_MEMBER_STATUS, &METRICS_MEMBER_EVENT_THRESHOLD],
   40     40   
);
   41     41   
impl Metrics {
   42     42   
    /// The schema for this shape.
   43     43   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &METRICS_SCHEMA;
   44     44   
}
   45     45   
impl ::aws_smithy_schema::serde::SerializableStruct for Metrics {
   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(&METRICS_MEMBER_STATUS, val.as_str())?;
   54     54   
        }
   55     55   
        if let Some(ref val) = self.event_threshold {
   56     56   
            ser.write_struct(&METRICS_MEMBER_EVENT_THRESHOLD, val)?;
   57     57   
        }
   58     58   
        Ok(())
   59     59   
    }
   60     60   
}
   61     61   
impl Metrics {
   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(&METRICS_SCHEMA, (), |_, member, deser| {
          75  +
        deserializer.read_struct(&METRICS_SCHEMA, &mut |member, deser| {
   76     76   
            match member.member_index() {
   77     77   
                Some(0) => {
   78     78   
                    builder.status = Some(crate::types::MetricsStatus::from(deser.read_string(member)?.as_str()));
   79     79   
                }
   80     80   
                Some(1) => {
   81     81   
                    builder.event_threshold = 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 Metrics {
          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 Metrics {
   93    104   
    /// Creates a new builder-style object to manufacture [`Metrics`](crate::types::Metrics).
   94    105   
    pub fn builder() -> crate::types::builders::MetricsBuilder {
   95    106   
        crate::types::builders::MetricsBuilder::default()
   96    107   
    }
   97    108   
}
   98    109   
   99    110   
/// A builder for [`Metrics`](crate::types::Metrics).
  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/_metrics_and_operator.rs

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

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

@@ -1,1 +125,134 @@
   18     18   
    /// <p>Specifies a metrics configuration filter. The metrics configuration will only include objects that meet the filter's criteria. A filter must be a prefix, an object tag, an access point ARN, or a conjunction (MetricsAndOperator).</p>
   19     19   
    pub fn filter(&self) -> ::std::option::Option<&crate::types::MetricsFilter> {
   20     20   
        self.filter.as_ref()
   21     21   
    }
   22     22   
}
   23     23   
static METRICSCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   24     24   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MetricsConfiguration", "com.amazonaws.s3", "MetricsConfiguration");
   25     25   
static METRICSCONFIGURATION_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   26     26   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MetricsConfiguration$Id", "com.amazonaws.s3", "MetricsConfiguration"),
   27     27   
    ::aws_smithy_schema::ShapeType::String,
   28         -
    "id",
          28  +
    "Id",
   29     29   
    0,
   30     30   
);
   31     31   
static METRICSCONFIGURATION_MEMBER_FILTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MetricsConfiguration$Filter", "com.amazonaws.s3", "MetricsConfiguration"),
   33     33   
    ::aws_smithy_schema::ShapeType::Union,
   34         -
    "filter",
          34  +
    "Filter",
   35     35   
    1,
   36     36   
);
   37     37   
static METRICSCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   38     38   
    METRICSCONFIGURATION_SCHEMA_ID,
   39     39   
    ::aws_smithy_schema::ShapeType::Structure,
   40     40   
    &[&METRICSCONFIGURATION_MEMBER_ID, &METRICSCONFIGURATION_MEMBER_FILTER],
   41     41   
);
   42     42   
impl MetricsConfiguration {
   43     43   
    /// The schema for this shape.
   44     44   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &METRICSCONFIGURATION_SCHEMA;
   45     45   
}
   46     46   
impl ::aws_smithy_schema::serde::SerializableStruct for MetricsConfiguration {
   47     47   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   48     48   
    fn serialize_members(
   49     49   
        &self,
   50     50   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   51     51   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        {
   53     53   
            let val = &self.id;
   54     54   
            ser.write_string(&METRICSCONFIGURATION_MEMBER_ID, val)?;
   55     55   
        }
   56     56   
        if let Some(ref val) = self.filter {
   57         -
            ser.write_null(&METRICSCONFIGURATION_MEMBER_FILTER)?;
          57  +
            ser.write_struct(&METRICSCONFIGURATION_MEMBER_FILTER, val)?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl MetricsConfiguration {
   63     63   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   64         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   65         -
        deserializer: &mut D,
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   66     66   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        #[allow(unused_variables, unused_mut)]
   68     68   
        let mut builder = Self::builder();
   69     69   
        #[allow(
   70     70   
            unused_variables,
   71     71   
            unreachable_code,
   72     72   
            clippy::single_match,
   73     73   
            clippy::match_single_binding,
   74     74   
            clippy::diverging_sub_expression
   75     75   
        )]
   76         -
        deserializer.read_struct(&METRICSCONFIGURATION_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&METRICSCONFIGURATION_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.id = Some(deser.read_string(member)?);
   80     80   
                }
   81     81   
                Some(1) => {
   82         -
                    builder.filter = Some({
   83         -
                        let _ = member;
   84         -
                        todo!("deserialize aggregate")
   85         -
                    });
          82  +
                    builder.filter = Some(crate::types::MetricsFilter::deserialize(deser)?);
   86     83   
                }
   87     84   
                _ => {}
   88     85   
            }
   89     86   
            Ok(())
   90     87   
        })?;
          88  +
        builder.id = builder.id.or(Some(String::new()));
   91     89   
        builder
   92     90   
            .build()
   93     91   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   94     92   
    }
   95     93   
}
          94  +
impl MetricsConfiguration {
          95  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          96  +
    pub fn deserialize_with_response(
          97  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          98  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          99  +
        _status: u16,
         100  +
        _body: &[u8],
         101  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         102  +
        Self::deserialize(deserializer)
         103  +
    }
         104  +
}
   96    105   
impl MetricsConfiguration {
   97    106   
    /// Creates a new builder-style object to manufacture [`MetricsConfiguration`](crate::types::MetricsConfiguration).
   98    107   
    pub fn builder() -> crate::types::builders::MetricsConfigurationBuilder {
   99    108   
        crate::types::builders::MetricsConfigurationBuilder::default()
  100    109   
    }
  101    110   
}
  102    111   
  103    112   
/// A builder for [`MetricsConfiguration`](crate::types::MetricsConfiguration).
  104    113   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  105    114   
#[non_exhaustive]

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

@@ -53,53 +0,166 @@
   73     73   
    }
   74     74   
    /// Returns true if this is a [`Tag`](crate::types::MetricsFilter::Tag).
   75     75   
    pub fn is_tag(&self) -> bool {
   76     76   
        self.as_tag().is_ok()
   77     77   
    }
   78     78   
    /// Returns true if the enum instance is the `Unknown` variant.
   79     79   
    pub fn is_unknown(&self) -> bool {
   80     80   
        matches!(self, Self::Unknown)
   81     81   
    }
   82     82   
}
          83  +
static METRICSFILTER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
          84  +
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MetricsFilter", "com.amazonaws.s3", "MetricsFilter");
          85  +
static METRICSFILTER_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          86  +
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MetricsFilter$Prefix", "com.amazonaws.s3", "MetricsFilter"),
          87  +
    ::aws_smithy_schema::ShapeType::String,
          88  +
    "Prefix",
          89  +
    0,
          90  +
);
          91  +
static METRICSFILTER_MEMBER_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          92  +
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MetricsFilter$Tag", "com.amazonaws.s3", "MetricsFilter"),
          93  +
    ::aws_smithy_schema::ShapeType::Structure,
          94  +
    "Tag",
          95  +
    1,
          96  +
);
          97  +
static METRICSFILTER_MEMBER_ACCESSPOINTARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          98  +
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MetricsFilter$AccessPointArn", "com.amazonaws.s3", "MetricsFilter"),
          99  +
    ::aws_smithy_schema::ShapeType::String,
         100  +
    "AccessPointArn",
         101  +
    2,
         102  +
);
         103  +
static METRICSFILTER_MEMBER_AND: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         104  +
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MetricsFilter$And", "com.amazonaws.s3", "MetricsFilter"),
         105  +
    ::aws_smithy_schema::ShapeType::Structure,
         106  +
    "And",
         107  +
    3,
         108  +
);
         109  +
static METRICSFILTER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
         110  +
    METRICSFILTER_SCHEMA_ID,
         111  +
    ::aws_smithy_schema::ShapeType::Union,
         112  +
    &[
         113  +
        &METRICSFILTER_MEMBER_PREFIX,
         114  +
        &METRICSFILTER_MEMBER_TAG,
         115  +
        &METRICSFILTER_MEMBER_ACCESSPOINTARN,
         116  +
        &METRICSFILTER_MEMBER_AND,
         117  +
    ],
         118  +
);
         119  +
impl MetricsFilter {
         120  +
    /// The schema for this shape.
         121  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &METRICSFILTER_SCHEMA;
         122  +
}
         123  +
impl ::aws_smithy_schema::serde::SerializableStruct for MetricsFilter {
         124  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         125  +
    fn serialize_members(
         126  +
        &self,
         127  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         128  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         129  +
        match self {
         130  +
            Self::Prefix(val) => {
         131  +
                ser.write_string(&METRICSFILTER_MEMBER_PREFIX, val)?;
         132  +
            }
         133  +
            Self::Tag(val) => {
         134  +
                ser.write_struct(&METRICSFILTER_MEMBER_TAG, val)?;
         135  +
            }
         136  +
            Self::AccessPointArn(val) => {
         137  +
                ser.write_string(&METRICSFILTER_MEMBER_ACCESSPOINTARN, val)?;
         138  +
            }
         139  +
            Self::And(val) => {
         140  +
                ser.write_struct(&METRICSFILTER_MEMBER_AND, val)?;
         141  +
            }
         142  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
         143  +
        }
         144  +
        Ok(())
         145  +
    }
         146  +
}
         147  +
impl MetricsFilter {
         148  +
    /// Deserializes this union from a [`ShapeDeserializer`].
         149  +
    pub fn deserialize(
         150  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         151  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         152  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
         153  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
         154  +
        deserializer.read_struct(&METRICSFILTER_SCHEMA, &mut |member, deser| {
         155  +
            result = ::std::option::Option::Some(match member.member_index() {
         156  +
                Some(0) => Self::Prefix(deser.read_string(member)?),
         157  +
                Some(1) => Self::Tag(crate::types::Tag::deserialize(deser)?),
         158  +
                Some(2) => Self::AccessPointArn(deser.read_string(member)?),
         159  +
                Some(3) => Self::And(crate::types::MetricsAndOperator::deserialize(deser)?),
         160  +
                _ => Self::Unknown,
         161  +
            });
         162  +
            Ok(())
         163  +
        })?;
         164  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
         165  +
    }
         166  +
}

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

@@ -41,41 +247,258 @@
   61     61   
    /// <p>The checksum type that is used to calculate the object’s checksum value. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   62     62   
    pub fn checksum_type(&self) -> ::std::option::Option<&crate::types::ChecksumType> {
   63     63   
        self.checksum_type.as_ref()
   64     64   
    }
   65     65   
}
   66     66   
static MULTIPARTUPLOAD_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MultipartUpload", "com.amazonaws.s3", "MultipartUpload");
   68     68   
static MULTIPARTUPLOAD_MEMBER_UPLOAD_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MultipartUpload$UploadId", "com.amazonaws.s3", "MultipartUpload"),
   70     70   
    ::aws_smithy_schema::ShapeType::String,
   71         -
    "upload_id",
          71  +
    "UploadId",
   72     72   
    0,
   73     73   
);
   74     74   
static MULTIPARTUPLOAD_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MultipartUpload$Key", "com.amazonaws.s3", "MultipartUpload"),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "key",
          77  +
    "Key",
   78     78   
    1,
   79     79   
);
   80     80   
static MULTIPARTUPLOAD_MEMBER_INITIATED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MultipartUpload$Initiated", "com.amazonaws.s3", "MultipartUpload"),
   82     82   
    ::aws_smithy_schema::ShapeType::Timestamp,
   83         -
    "initiated",
          83  +
    "Initiated",
   84     84   
    2,
   85     85   
);
   86     86   
static MULTIPARTUPLOAD_MEMBER_STORAGE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MultipartUpload$StorageClass", "com.amazonaws.s3", "MultipartUpload"),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "storage_class",
          89  +
    "StorageClass",
   90     90   
    3,
   91     91   
);
   92     92   
static MULTIPARTUPLOAD_MEMBER_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MultipartUpload$Owner", "com.amazonaws.s3", "MultipartUpload"),
   94     94   
    ::aws_smithy_schema::ShapeType::Structure,
   95         -
    "owner",
          95  +
    "Owner",
   96     96   
    4,
   97     97   
);
   98     98   
static MULTIPARTUPLOAD_MEMBER_INITIATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MultipartUpload$Initiator", "com.amazonaws.s3", "MultipartUpload"),
  100    100   
    ::aws_smithy_schema::ShapeType::Structure,
  101         -
    "initiator",
         101  +
    "Initiator",
  102    102   
    5,
  103    103   
);
  104    104   
static MULTIPARTUPLOAD_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static(
  106    106   
        "com.amazonaws.s3#MultipartUpload$ChecksumAlgorithm",
  107    107   
        "com.amazonaws.s3",
  108    108   
        "MultipartUpload",
  109    109   
    ),
  110    110   
    ::aws_smithy_schema::ShapeType::String,
  111         -
    "checksum_algorithm",
         111  +
    "ChecksumAlgorithm",
  112    112   
    6,
  113    113   
);
  114    114   
static MULTIPARTUPLOAD_MEMBER_CHECKSUM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#MultipartUpload$ChecksumType", "com.amazonaws.s3", "MultipartUpload"),
  116    116   
    ::aws_smithy_schema::ShapeType::String,
  117         -
    "checksum_type",
         117  +
    "ChecksumType",
  118    118   
    7,
  119    119   
);
  120    120   
static MULTIPARTUPLOAD_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  121    121   
    MULTIPARTUPLOAD_SCHEMA_ID,
  122    122   
    ::aws_smithy_schema::ShapeType::Structure,
  123    123   
    &[
  124    124   
        &MULTIPARTUPLOAD_MEMBER_UPLOAD_ID,
  125    125   
        &MULTIPARTUPLOAD_MEMBER_KEY,
  126    126   
        &MULTIPARTUPLOAD_MEMBER_INITIATED,
  127    127   
        &MULTIPARTUPLOAD_MEMBER_STORAGE_CLASS,
  128    128   
        &MULTIPARTUPLOAD_MEMBER_OWNER,
  129    129   
        &MULTIPARTUPLOAD_MEMBER_INITIATOR,
  130    130   
        &MULTIPARTUPLOAD_MEMBER_CHECKSUM_ALGORITHM,
  131    131   
        &MULTIPARTUPLOAD_MEMBER_CHECKSUM_TYPE,
  132    132   
    ],
  133    133   
);
  134    134   
impl MultipartUpload {
  135    135   
    /// The schema for this shape.
  136    136   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MULTIPARTUPLOAD_SCHEMA;
  137    137   
}
  138    138   
impl ::aws_smithy_schema::serde::SerializableStruct for MultipartUpload {
  139    139   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  140    140   
    fn serialize_members(
  141    141   
        &self,
  142    142   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  143    143   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  144    144   
        if let Some(ref val) = self.upload_id {
  145    145   
            ser.write_string(&MULTIPARTUPLOAD_MEMBER_UPLOAD_ID, val)?;
  146    146   
        }
  147    147   
        if let Some(ref val) = self.key {
  148    148   
            ser.write_string(&MULTIPARTUPLOAD_MEMBER_KEY, val)?;
  149    149   
        }
  150    150   
        if let Some(ref val) = self.initiated {
  151    151   
            ser.write_timestamp(&MULTIPARTUPLOAD_MEMBER_INITIATED, val)?;
  152    152   
        }
  153    153   
        if let Some(ref val) = self.storage_class {
  154    154   
            ser.write_string(&MULTIPARTUPLOAD_MEMBER_STORAGE_CLASS, val.as_str())?;
  155    155   
        }
  156    156   
        if let Some(ref val) = self.owner {
  157    157   
            ser.write_struct(&MULTIPARTUPLOAD_MEMBER_OWNER, val)?;
  158    158   
        }
  159    159   
        if let Some(ref val) = self.initiator {
  160    160   
            ser.write_struct(&MULTIPARTUPLOAD_MEMBER_INITIATOR, val)?;
  161    161   
        }
  162    162   
        if let Some(ref val) = self.checksum_algorithm {
  163    163   
            ser.write_string(&MULTIPARTUPLOAD_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
  164    164   
        }
  165    165   
        if let Some(ref val) = self.checksum_type {
  166    166   
            ser.write_string(&MULTIPARTUPLOAD_MEMBER_CHECKSUM_TYPE, val.as_str())?;
  167    167   
        }
  168    168   
        Ok(())
  169    169   
    }
  170    170   
}
  171    171   
impl MultipartUpload {
  172    172   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  173         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  174         -
        deserializer: &mut D,
         173  +
    pub fn deserialize(
         174  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  175    175   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  176    176   
        #[allow(unused_variables, unused_mut)]
  177    177   
        let mut builder = Self::builder();
  178    178   
        #[allow(
  179    179   
            unused_variables,
  180    180   
            unreachable_code,
  181    181   
            clippy::single_match,
  182    182   
            clippy::match_single_binding,
  183    183   
            clippy::diverging_sub_expression
  184    184   
        )]
  185         -
        deserializer.read_struct(&MULTIPARTUPLOAD_SCHEMA, (), |_, member, deser| {
         185  +
        deserializer.read_struct(&MULTIPARTUPLOAD_SCHEMA, &mut |member, deser| {
  186    186   
            match member.member_index() {
  187    187   
                Some(0) => {
  188    188   
                    builder.upload_id = Some(deser.read_string(member)?);
  189    189   
                }
  190    190   
                Some(1) => {
  191    191   
                    builder.key = Some(deser.read_string(member)?);
  192    192   
                }
  193    193   
                Some(2) => {
  194    194   
                    builder.initiated = Some(deser.read_timestamp(member)?);
  195    195   
                }
  196    196   
                Some(3) => {
  197    197   
                    builder.storage_class = Some(crate::types::StorageClass::from(deser.read_string(member)?.as_str()));
  198    198   
                }
  199    199   
                Some(4) => {
  200    200   
                    builder.owner = Some(crate::types::Owner::deserialize(deser)?);
  201    201   
                }
  202    202   
                Some(5) => {
  203    203   
                    builder.initiator = Some(crate::types::Initiator::deserialize(deser)?);
  204    204   
                }
  205    205   
                Some(6) => {
  206    206   
                    builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
  207    207   
                }
  208    208   
                Some(7) => {
  209    209   
                    builder.checksum_type = Some(crate::types::ChecksumType::from(deser.read_string(member)?.as_str()));
  210    210   
                }
  211    211   
                _ => {}
  212    212   
            }
  213    213   
            Ok(())
  214    214   
        })?;
  215    215   
        Ok(builder.build())
  216    216   
    }
  217    217   
}
         218  +
impl MultipartUpload {
         219  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         220  +
    pub fn deserialize_with_response(
         221  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         222  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         223  +
        _status: u16,
         224  +
        _body: &[u8],
         225  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         226  +
        Self::deserialize(deserializer)
         227  +
    }
         228  +
}
  218    229   
impl MultipartUpload {
  219    230   
    /// Creates a new builder-style object to manufacture [`MultipartUpload`](crate::types::MultipartUpload).
  220    231   
    pub fn builder() -> crate::types::builders::MultipartUploadBuilder {
  221    232   
        crate::types::builders::MultipartUploadBuilder::default()
  222    233   
    }
  223    234   
}
  224    235   
  225    236   
/// A builder for [`MultipartUpload`](crate::types::MultipartUpload).
  226    237   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  227    238   
#[non_exhaustive]

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

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

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

@@ -10,10 +155,166 @@
   30     30   
    "com.amazonaws.s3",
   31     31   
    "NoncurrentVersionTransition",
   32     32   
);
   33     33   
static NONCURRENTVERSIONTRANSITION_MEMBER_NONCURRENT_DAYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.s3#NoncurrentVersionTransition$NoncurrentDays",
   36     36   
        "com.amazonaws.s3",
   37     37   
        "NoncurrentVersionTransition",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Integer,
   40         -
    "noncurrent_days",
          40  +
    "NoncurrentDays",
   41     41   
    0,
   42     42   
);
   43     43   
static NONCURRENTVERSIONTRANSITION_MEMBER_STORAGE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.s3#NoncurrentVersionTransition$StorageClass",
   46     46   
        "com.amazonaws.s3",
   47     47   
        "NoncurrentVersionTransition",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "storage_class",
          50  +
    "StorageClass",
   51     51   
    1,
   52     52   
);
   53     53   
static NONCURRENTVERSIONTRANSITION_MEMBER_NEWER_NONCURRENT_VERSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.s3#NoncurrentVersionTransition$NewerNoncurrentVersions",
   56     56   
        "com.amazonaws.s3",
   57     57   
        "NoncurrentVersionTransition",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Integer,
   60         -
    "newer_noncurrent_versions",
          60  +
    "NewerNoncurrentVersions",
   61     61   
    2,
   62     62   
);
   63     63   
static NONCURRENTVERSIONTRANSITION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    NONCURRENTVERSIONTRANSITION_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &NONCURRENTVERSIONTRANSITION_MEMBER_NONCURRENT_DAYS,
   68     68   
        &NONCURRENTVERSIONTRANSITION_MEMBER_STORAGE_CLASS,
   69     69   
        &NONCURRENTVERSIONTRANSITION_MEMBER_NEWER_NONCURRENT_VERSIONS,
   70     70   
    ],
   71     71   
);
   72     72   
impl NoncurrentVersionTransition {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NONCURRENTVERSIONTRANSITION_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for NoncurrentVersionTransition {
   77     77   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   78     78   
    fn serialize_members(
   79     79   
        &self,
   80     80   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   81     81   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   82     82   
        if let Some(ref val) = self.noncurrent_days {
   83     83   
            ser.write_integer(&NONCURRENTVERSIONTRANSITION_MEMBER_NONCURRENT_DAYS, *val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.storage_class {
   86     86   
            ser.write_string(&NONCURRENTVERSIONTRANSITION_MEMBER_STORAGE_CLASS, val.as_str())?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.newer_noncurrent_versions {
   89     89   
            ser.write_integer(&NONCURRENTVERSIONTRANSITION_MEMBER_NEWER_NONCURRENT_VERSIONS, *val)?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl NoncurrentVersionTransition {
   95     95   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   96         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   97         -
        deserializer: &mut D,
          96  +
    pub fn deserialize(
          97  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   98     98   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   99     99   
        #[allow(unused_variables, unused_mut)]
  100    100   
        let mut builder = Self::builder();
  101    101   
        #[allow(
  102    102   
            unused_variables,
  103    103   
            unreachable_code,
  104    104   
            clippy::single_match,
  105    105   
            clippy::match_single_binding,
  106    106   
            clippy::diverging_sub_expression
  107    107   
        )]
  108         -
        deserializer.read_struct(&NONCURRENTVERSIONTRANSITION_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&NONCURRENTVERSIONTRANSITION_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.noncurrent_days = Some(deser.read_integer(member)?);
  112    112   
                }
  113    113   
                Some(1) => {
  114    114   
                    builder.storage_class = Some(crate::types::TransitionStorageClass::from(deser.read_string(member)?.as_str()));
  115    115   
                }
  116    116   
                Some(2) => {
  117    117   
                    builder.newer_noncurrent_versions = Some(deser.read_integer(member)?);
  118    118   
                }
  119    119   
                _ => {}
  120    120   
            }
  121    121   
            Ok(())
  122    122   
        })?;
  123    123   
        Ok(builder.build())
  124    124   
    }
  125    125   
}
         126  +
impl NoncurrentVersionTransition {
         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  +
}
  126    137   
impl NoncurrentVersionTransition {
  127    138   
    /// Creates a new builder-style object to manufacture [`NoncurrentVersionTransition`](crate::types::NoncurrentVersionTransition).
  128    139   
    pub fn builder() -> crate::types::builders::NoncurrentVersionTransitionBuilder {
  129    140   
        crate::types::builders::NoncurrentVersionTransitionBuilder::default()
  130    141   
    }
  131    142   
}
  132    143   
  133    144   
/// A builder for [`NoncurrentVersionTransition`](crate::types::NoncurrentVersionTransition).
  134    145   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  135    146   
#[non_exhaustive]

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

@@ -22,22 +118,118 @@
   42     42   
    "com.amazonaws.s3",
   43     43   
    "NotificationConfiguration",
   44     44   
);
   45     45   
static NOTIFICATIONCONFIGURATION_MEMBER_TOPIC_CONFIGURATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static(
   47     47   
        "com.amazonaws.s3#NotificationConfiguration$TopicConfigurations",
   48     48   
        "com.amazonaws.s3",
   49     49   
        "NotificationConfiguration",
   50     50   
    ),
   51     51   
    ::aws_smithy_schema::ShapeType::List,
   52         -
    "topic_configurations",
          52  +
    "TopicConfigurations",
   53     53   
    0,
   54     54   
)
   55     55   
.with_xml_name("TopicConfiguration")
   56     56   
.with_xml_flattened();
   57     57   
static NOTIFICATIONCONFIGURATION_MEMBER_QUEUE_CONFIGURATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.s3#NotificationConfiguration$QueueConfigurations",
   60     60   
        "com.amazonaws.s3",
   61     61   
        "NotificationConfiguration",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::List,
   64         -
    "queue_configurations",
          64  +
    "QueueConfigurations",
   65     65   
    1,
   66     66   
)
   67     67   
.with_xml_name("QueueConfiguration")
   68     68   
.with_xml_flattened();
   69     69   
static NOTIFICATIONCONFIGURATION_MEMBER_LAMBDA_FUNCTION_CONFIGURATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.s3#NotificationConfiguration$LambdaFunctionConfigurations",
   72     72   
        "com.amazonaws.s3",
   73     73   
        "NotificationConfiguration",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::List,
   76         -
    "lambda_function_configurations",
          76  +
    "LambdaFunctionConfigurations",
   77     77   
    2,
   78     78   
)
   79     79   
.with_xml_name("CloudFunctionConfiguration")
   80     80   
.with_xml_flattened();
   81     81   
static NOTIFICATIONCONFIGURATION_MEMBER_EVENT_BRIDGE_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.s3#NotificationConfiguration$EventBridgeConfiguration",
   84     84   
        "com.amazonaws.s3",
   85     85   
        "NotificationConfiguration",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::Structure,
   88         -
    "event_bridge_configuration",
          88  +
    "EventBridgeConfiguration",
   89     89   
    3,
   90     90   
);
   91     91   
static NOTIFICATIONCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   92     92   
    NOTIFICATIONCONFIGURATION_SCHEMA_ID,
   93     93   
    ::aws_smithy_schema::ShapeType::Structure,
   94     94   
    &[
   95     95   
        &NOTIFICATIONCONFIGURATION_MEMBER_TOPIC_CONFIGURATIONS,
   96     96   
        &NOTIFICATIONCONFIGURATION_MEMBER_QUEUE_CONFIGURATIONS,
   97     97   
        &NOTIFICATIONCONFIGURATION_MEMBER_LAMBDA_FUNCTION_CONFIGURATIONS,
   98     98   
        &NOTIFICATIONCONFIGURATION_MEMBER_EVENT_BRIDGE_CONFIGURATION,
@@ -122,122 +244,246 @@
  142    142   
            )?;
  143    143   
        }
  144    144   
        if let Some(ref val) = self.event_bridge_configuration {
  145    145   
            ser.write_struct(&NOTIFICATIONCONFIGURATION_MEMBER_EVENT_BRIDGE_CONFIGURATION, val)?;
  146    146   
        }
  147    147   
        Ok(())
  148    148   
    }
  149    149   
}
  150    150   
impl NotificationConfiguration {
  151    151   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  152         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  153         -
        deserializer: &mut D,
         152  +
    pub fn deserialize(
         153  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  154    154   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  155    155   
        #[allow(unused_variables, unused_mut)]
  156    156   
        let mut builder = Self::builder();
  157    157   
        #[allow(
  158    158   
            unused_variables,
  159    159   
            unreachable_code,
  160    160   
            clippy::single_match,
  161    161   
            clippy::match_single_binding,
  162    162   
            clippy::diverging_sub_expression
  163    163   
        )]
  164         -
        deserializer.read_struct(&NOTIFICATIONCONFIGURATION_SCHEMA, (), |_, member, deser| {
         164  +
        deserializer.read_struct(&NOTIFICATIONCONFIGURATION_SCHEMA, &mut |member, deser| {
  165    165   
            match member.member_index() {
  166    166   
                Some(0) => {
  167    167   
                    builder.topic_configurations = Some({
  168         -
                        let container = if let Some(cap) = deser.container_size() {
  169         -
                            Vec::with_capacity(cap)
  170         -
                        } else {
  171         -
                            Vec::new()
  172         -
                        };
  173         -
                        deser.read_list(member, container, |mut list, deser| {
  174         -
                            list.push(crate::types::TopicConfiguration::deserialize(deser)?);
  175         -
                            Ok(list)
  176         -
                        })?
         168  +
                        let mut container = Vec::new();
         169  +
                        deser.read_list(member, &mut |deser| {
         170  +
                            container.push(crate::types::TopicConfiguration::deserialize(deser)?);
         171  +
                            Ok(())
         172  +
                        })?;
         173  +
                        container
  177    174   
                    });
  178    175   
                }
  179    176   
                Some(1) => {
  180    177   
                    builder.queue_configurations = Some({
  181         -
                        let container = if let Some(cap) = deser.container_size() {
  182         -
                            Vec::with_capacity(cap)
  183         -
                        } else {
  184         -
                            Vec::new()
  185         -
                        };
  186         -
                        deser.read_list(member, container, |mut list, deser| {
  187         -
                            list.push(crate::types::QueueConfiguration::deserialize(deser)?);
  188         -
                            Ok(list)
  189         -
                        })?
         178  +
                        let mut container = Vec::new();
         179  +
                        deser.read_list(member, &mut |deser| {
         180  +
                            container.push(crate::types::QueueConfiguration::deserialize(deser)?);
         181  +
                            Ok(())
         182  +
                        })?;
         183  +
                        container
  190    184   
                    });
  191    185   
                }
  192    186   
                Some(2) => {
  193    187   
                    builder.lambda_function_configurations = Some({
  194         -
                        let container = if let Some(cap) = deser.container_size() {
  195         -
                            Vec::with_capacity(cap)
  196         -
                        } else {
  197         -
                            Vec::new()
  198         -
                        };
  199         -
                        deser.read_list(member, container, |mut list, deser| {
  200         -
                            list.push(crate::types::LambdaFunctionConfiguration::deserialize(deser)?);
  201         -
                            Ok(list)
  202         -
                        })?
         188  +
                        let mut container = Vec::new();
         189  +
                        deser.read_list(member, &mut |deser| {
         190  +
                            container.push(crate::types::LambdaFunctionConfiguration::deserialize(deser)?);
         191  +
                            Ok(())
         192  +
                        })?;
         193  +
                        container
  203    194   
                    });
  204    195   
                }
  205    196   
                Some(3) => {
  206    197   
                    builder.event_bridge_configuration = Some(crate::types::EventBridgeConfiguration::deserialize(deser)?);
  207    198   
                }
  208    199   
                _ => {}
  209    200   
            }
  210    201   
            Ok(())
  211    202   
        })?;
  212    203   
        Ok(builder.build())
  213    204   
    }
  214    205   
}
         206  +
impl NotificationConfiguration {
         207  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         208  +
    pub fn deserialize_with_response(
         209  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         210  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         211  +
        _status: u16,
         212  +
        _body: &[u8],
         213  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         214  +
        Self::deserialize(deserializer)
         215  +
    }
         216  +
}
  215    217   
impl NotificationConfiguration {
  216    218   
    /// Creates a new builder-style object to manufacture [`NotificationConfiguration`](crate::types::NotificationConfiguration).
  217    219   
    pub fn builder() -> crate::types::builders::NotificationConfigurationBuilder {
  218    220   
        crate::types::builders::NotificationConfigurationBuilder::default()
  219    221   
    }
  220    222   
}
  221    223   
  222    224   
/// A builder for [`NotificationConfiguration`](crate::types::NotificationConfiguration).
  223    225   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  224    226   
#[non_exhaustive]

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

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

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

@@ -73,73 +182,182 @@
   93     93   
    /// </note>
   94     94   
    pub fn restore_status(&self) -> ::std::option::Option<&crate::types::RestoreStatus> {
   95     95   
        self.restore_status.as_ref()
   96     96   
    }
   97     97   
}
   98     98   
static OBJECT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   99     99   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Object", "com.amazonaws.s3", "Object");
  100    100   
static OBJECT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Object$Key", "com.amazonaws.s3", "Object"),
  102    102   
    ::aws_smithy_schema::ShapeType::String,
  103         -
    "key",
         103  +
    "Key",
  104    104   
    0,
  105    105   
);
  106    106   
static OBJECT_MEMBER_LAST_MODIFIED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Object$LastModified", "com.amazonaws.s3", "Object"),
  108    108   
    ::aws_smithy_schema::ShapeType::Timestamp,
  109         -
    "last_modified",
         109  +
    "LastModified",
  110    110   
    1,
  111    111   
);
  112    112   
static OBJECT_MEMBER_E_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Object$ETag", "com.amazonaws.s3", "Object"),
  114    114   
    ::aws_smithy_schema::ShapeType::String,
  115         -
    "e_tag",
         115  +
    "ETag",
  116    116   
    2,
  117    117   
);
  118    118   
static OBJECT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Object$ChecksumAlgorithm", "com.amazonaws.s3", "Object"),
  120    120   
    ::aws_smithy_schema::ShapeType::List,
  121         -
    "checksum_algorithm",
         121  +
    "ChecksumAlgorithm",
  122    122   
    3,
  123    123   
)
  124    124   
.with_xml_flattened();
  125    125   
static OBJECT_MEMBER_CHECKSUM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Object$ChecksumType", "com.amazonaws.s3", "Object"),
  127    127   
    ::aws_smithy_schema::ShapeType::String,
  128         -
    "checksum_type",
         128  +
    "ChecksumType",
  129    129   
    4,
  130    130   
);
  131    131   
static OBJECT_MEMBER_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  132    132   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Object$Size", "com.amazonaws.s3", "Object"),
  133    133   
    ::aws_smithy_schema::ShapeType::Long,
  134         -
    "size",
         134  +
    "Size",
  135    135   
    5,
  136    136   
);
  137    137   
static OBJECT_MEMBER_STORAGE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Object$StorageClass", "com.amazonaws.s3", "Object"),
  139    139   
    ::aws_smithy_schema::ShapeType::String,
  140         -
    "storage_class",
         140  +
    "StorageClass",
  141    141   
    6,
  142    142   
);
  143    143   
static OBJECT_MEMBER_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  144    144   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Object$Owner", "com.amazonaws.s3", "Object"),
  145    145   
    ::aws_smithy_schema::ShapeType::Structure,
  146         -
    "owner",
         146  +
    "Owner",
  147    147   
    7,
  148    148   
);
  149    149   
static OBJECT_MEMBER_RESTORE_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#Object$RestoreStatus", "com.amazonaws.s3", "Object"),
  151    151   
    ::aws_smithy_schema::ShapeType::Structure,
  152         -
    "restore_status",
         152  +
    "RestoreStatus",
  153    153   
    8,
  154    154   
);
  155    155   
static OBJECT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  156    156   
    OBJECT_SCHEMA_ID,
  157    157   
    ::aws_smithy_schema::ShapeType::Structure,
  158    158   
    &[
  159    159   
        &OBJECT_MEMBER_KEY,
  160    160   
        &OBJECT_MEMBER_LAST_MODIFIED,
  161    161   
        &OBJECT_MEMBER_E_TAG,
  162    162   
        &OBJECT_MEMBER_CHECKSUM_ALGORITHM,
@@ -190,190 +307,315 @@
  210    210   
            ser.write_struct(&OBJECT_MEMBER_OWNER, val)?;
  211    211   
        }
  212    212   
        if let Some(ref val) = self.restore_status {
  213    213   
            ser.write_struct(&OBJECT_MEMBER_RESTORE_STATUS, val)?;
  214    214   
        }
  215    215   
        Ok(())
  216    216   
    }
  217    217   
}
  218    218   
impl Object {
  219    219   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  220         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  221         -
        deserializer: &mut D,
         220  +
    pub fn deserialize(
         221  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  222    222   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  223    223   
        #[allow(unused_variables, unused_mut)]
  224    224   
        let mut builder = Self::builder();
  225    225   
        #[allow(
  226    226   
            unused_variables,
  227    227   
            unreachable_code,
  228    228   
            clippy::single_match,
  229    229   
            clippy::match_single_binding,
  230    230   
            clippy::diverging_sub_expression
  231    231   
        )]
  232         -
        deserializer.read_struct(&OBJECT_SCHEMA, (), |_, member, deser| {
         232  +
        deserializer.read_struct(&OBJECT_SCHEMA, &mut |member, deser| {
  233    233   
            match member.member_index() {
  234    234   
                Some(0) => {
  235    235   
                    builder.key = Some(deser.read_string(member)?);
  236    236   
                }
  237    237   
                Some(1) => {
  238    238   
                    builder.last_modified = Some(deser.read_timestamp(member)?);
  239    239   
                }
  240    240   
                Some(2) => {
  241    241   
                    builder.e_tag = Some(deser.read_string(member)?);
  242    242   
                }
  243    243   
                Some(3) => {
  244    244   
                    builder.checksum_algorithm = Some({
  245         -
                        let container = if let Some(cap) = deser.container_size() {
  246         -
                            Vec::with_capacity(cap)
  247         -
                        } else {
  248         -
                            Vec::new()
  249         -
                        };
  250         -
                        deser.read_list(member, container, |mut list, deser| {
  251         -
                            list.push(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
  252         -
                            Ok(list)
  253         -
                        })?
         245  +
                        let mut container = Vec::new();
         246  +
                        deser.read_list(member, &mut |deser| {
         247  +
                            container.push(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
         248  +
                            Ok(())
         249  +
                        })?;
         250  +
                        container
  254    251   
                    });
  255    252   
                }
  256    253   
                Some(4) => {
  257    254   
                    builder.checksum_type = Some(crate::types::ChecksumType::from(deser.read_string(member)?.as_str()));
  258    255   
                }
  259    256   
                Some(5) => {
  260    257   
                    builder.size = Some(deser.read_long(member)?);
  261    258   
                }
  262    259   
                Some(6) => {
  263    260   
                    builder.storage_class = Some(crate::types::ObjectStorageClass::from(deser.read_string(member)?.as_str()));
  264    261   
                }
  265    262   
                Some(7) => {
  266    263   
                    builder.owner = Some(crate::types::Owner::deserialize(deser)?);
  267    264   
                }
  268    265   
                Some(8) => {
  269    266   
                    builder.restore_status = Some(crate::types::RestoreStatus::deserialize(deser)?);
  270    267   
                }
  271    268   
                _ => {}
  272    269   
            }
  273    270   
            Ok(())
  274    271   
        })?;
  275    272   
        Ok(builder.build())
  276    273   
    }
  277    274   
}
         275  +
impl Object {
         276  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         277  +
    pub fn deserialize_with_response(
         278  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         279  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         280  +
        _status: u16,
         281  +
        _body: &[u8],
         282  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         283  +
        Self::deserialize(deserializer)
         284  +
    }
         285  +
}
  278    286   
impl Object {
  279    287   
    /// Creates a new builder-style object to manufacture [`Object`](crate::types::Object).
  280    288   
    pub fn builder() -> crate::types::builders::ObjectBuilder {
  281    289   
        crate::types::builders::ObjectBuilder::default()
  282    290   
    }
  283    291   
}
  284    292   
  285    293   
/// A builder for [`Object`](crate::types::Object).
  286    294   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  287    295   
#[non_exhaustive]

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

@@ -36,36 +206,219 @@
   56     56   
    /// </note>
   57     57   
    pub fn size(&self) -> ::std::option::Option<i64> {
   58     58   
        self.size
   59     59   
    }
   60     60   
}
   61     61   
static OBJECTIDENTIFIER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   62     62   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectIdentifier", "com.amazonaws.s3", "ObjectIdentifier");
   63     63   
static OBJECTIDENTIFIER_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectIdentifier$Key", "com.amazonaws.s3", "ObjectIdentifier"),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "key",
          66  +
    "Key",
   67     67   
    0,
   68     68   
);
   69     69   
static OBJECTIDENTIFIER_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectIdentifier$VersionId", "com.amazonaws.s3", "ObjectIdentifier"),
   71     71   
    ::aws_smithy_schema::ShapeType::String,
   72         -
    "version_id",
          72  +
    "VersionId",
   73     73   
    1,
   74     74   
);
   75     75   
static OBJECTIDENTIFIER_MEMBER_E_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectIdentifier$ETag", "com.amazonaws.s3", "ObjectIdentifier"),
   77     77   
    ::aws_smithy_schema::ShapeType::String,
   78         -
    "e_tag",
          78  +
    "ETag",
   79     79   
    2,
   80     80   
);
   81     81   
static OBJECTIDENTIFIER_MEMBER_LAST_MODIFIED_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.s3#ObjectIdentifier$LastModifiedTime",
   84     84   
        "com.amazonaws.s3",
   85     85   
        "ObjectIdentifier",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::Timestamp,
   88         -
    "last_modified_time",
          88  +
    "LastModifiedTime",
   89     89   
    3,
   90         -
);
          90  +
)
          91  +
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::HttpDate);
   91     92   
static OBJECTIDENTIFIER_MEMBER_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     93   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#ObjectIdentifier$Size", "com.amazonaws.s3", "ObjectIdentifier"),
   93     94   
    ::aws_smithy_schema::ShapeType::Long,
   94         -
    "size",
          95  +
    "Size",
   95     96   
    4,
   96     97   
);
   97     98   
static OBJECTIDENTIFIER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   98     99   
    OBJECTIDENTIFIER_SCHEMA_ID,
   99    100   
    ::aws_smithy_schema::ShapeType::Structure,
  100    101   
    &[
  101    102   
        &OBJECTIDENTIFIER_MEMBER_KEY,
  102    103   
        &OBJECTIDENTIFIER_MEMBER_VERSION_ID,
  103    104   
        &OBJECTIDENTIFIER_MEMBER_E_TAG,
  104    105   
        &OBJECTIDENTIFIER_MEMBER_LAST_MODIFIED_TIME,
  105    106   
        &OBJECTIDENTIFIER_MEMBER_SIZE,
  106    107   
    ],
  107    108   
);
  108    109   
impl ObjectIdentifier {
  109    110   
    /// The schema for this shape.
  110    111   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OBJECTIDENTIFIER_SCHEMA;
  111    112   
}
  112    113   
impl ::aws_smithy_schema::serde::SerializableStruct for ObjectIdentifier {
  113    114   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  114    115   
    fn serialize_members(
  115    116   
        &self,
  116    117   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  117    118   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  118    119   
        {
  119    120   
            let val = &self.key;
  120    121   
            ser.write_string(&OBJECTIDENTIFIER_MEMBER_KEY, val)?;
  121    122   
        }
  122    123   
        if let Some(ref val) = self.version_id {
  123    124   
            ser.write_string(&OBJECTIDENTIFIER_MEMBER_VERSION_ID, val)?;
  124    125   
        }
  125    126   
        if let Some(ref val) = self.e_tag {
  126    127   
            ser.write_string(&OBJECTIDENTIFIER_MEMBER_E_TAG, val)?;
  127    128   
        }
  128    129   
        if let Some(ref val) = self.last_modified_time {
  129    130   
            ser.write_timestamp(&OBJECTIDENTIFIER_MEMBER_LAST_MODIFIED_TIME, val)?;
  130    131   
        }
  131    132   
        if let Some(ref val) = self.size {
  132    133   
            ser.write_long(&OBJECTIDENTIFIER_MEMBER_SIZE, *val)?;
  133    134   
        }
  134    135   
        Ok(())
  135    136   
    }
  136    137   
}
  137    138   
impl ObjectIdentifier {
  138    139   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  139         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  140         -
        deserializer: &mut D,
         140  +
    pub fn deserialize(
         141  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  141    142   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  142    143   
        #[allow(unused_variables, unused_mut)]
  143    144   
        let mut builder = Self::builder();
  144    145   
        #[allow(
  145    146   
            unused_variables,
  146    147   
            unreachable_code,
  147    148   
            clippy::single_match,
  148    149   
            clippy::match_single_binding,
  149    150   
            clippy::diverging_sub_expression
  150    151   
        )]
  151         -
        deserializer.read_struct(&OBJECTIDENTIFIER_SCHEMA, (), |_, member, deser| {
         152  +
        deserializer.read_struct(&OBJECTIDENTIFIER_SCHEMA, &mut |member, deser| {
  152    153   
            match member.member_index() {
  153    154   
                Some(0) => {
  154    155   
                    builder.key = Some(deser.read_string(member)?);
  155    156   
                }
  156    157   
                Some(1) => {
  157    158   
                    builder.version_id = Some(deser.read_string(member)?);
  158    159   
                }
  159    160   
                Some(2) => {
  160    161   
                    builder.e_tag = Some(deser.read_string(member)?);
  161    162   
                }
  162    163   
                Some(3) => {
  163    164   
                    builder.last_modified_time = Some(deser.read_timestamp(member)?);
  164    165   
                }
  165    166   
                Some(4) => {
  166    167   
                    builder.size = Some(deser.read_long(member)?);
  167    168   
                }
  168    169   
                _ => {}
  169    170   
            }
  170    171   
            Ok(())
  171    172   
        })?;
         173  +
        builder.key = builder.key.or(Some(String::new()));
  172    174   
        builder
  173    175   
            .build()
  174    176   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  175    177   
    }
  176    178   
}
         179  +
impl ObjectIdentifier {
         180  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         181  +
    pub fn deserialize_with_response(
         182  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         183  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         184  +
        _status: u16,
         185  +
        _body: &[u8],
         186  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         187  +
        Self::deserialize(deserializer)
         188  +
    }
         189  +
}
  177    190   
impl ObjectIdentifier {
  178    191   
    /// Creates a new builder-style object to manufacture [`ObjectIdentifier`](crate::types::ObjectIdentifier).
  179    192   
    pub fn builder() -> crate::types::builders::ObjectIdentifierBuilder {
  180    193   
        crate::types::builders::ObjectIdentifierBuilder::default()
  181    194   
    }
  182    195   
}
  183    196   
  184    197   
/// A builder for [`ObjectIdentifier`](crate::types::ObjectIdentifier).
  185    198   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  186    199   
#[non_exhaustive]

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

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

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

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