AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045

Files changed:

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

@@ -46,46 +228,239 @@
   66     66   
    "com.amazonaws.s3",
   67     67   
    "InventoryTableConfigurationResult",
   68     68   
);
   69     69   
static INVENTORYTABLECONFIGURATIONRESULT_MEMBER_CONFIGURATION_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.s3#InventoryTableConfigurationResult$ConfigurationState",
   72     72   
        "com.amazonaws.s3",
   73     73   
        "InventoryTableConfigurationResult",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "configuration_state",
          76  +
    "ConfigurationState",
   77     77   
    0,
   78     78   
);
   79     79   
static INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.s3#InventoryTableConfigurationResult$TableStatus",
   82     82   
        "com.amazonaws.s3",
   83     83   
        "InventoryTableConfigurationResult",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86         -
    "table_status",
          86  +
    "TableStatus",
   87     87   
    1,
   88     88   
);
   89     89   
static INVENTORYTABLECONFIGURATIONRESULT_MEMBER_ERROR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.s3#InventoryTableConfigurationResult$Error",
   92     92   
        "com.amazonaws.s3",
   93     93   
        "InventoryTableConfigurationResult",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::Structure,
   96         -
    "error",
          96  +
    "Error",
   97     97   
    2,
   98     98   
);
   99     99   
static INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.s3#InventoryTableConfigurationResult$TableName",
  102    102   
        "com.amazonaws.s3",
  103    103   
        "InventoryTableConfigurationResult",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::String,
  106         -
    "table_name",
         106  +
    "TableName",
  107    107   
    3,
  108    108   
);
  109    109   
static INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.s3#InventoryTableConfigurationResult$TableArn",
  112    112   
        "com.amazonaws.s3",
  113    113   
        "InventoryTableConfigurationResult",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "table_arn",
         116  +
    "TableArn",
  117    117   
    4,
  118    118   
);
  119    119   
static INVENTORYTABLECONFIGURATIONRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  120    120   
    INVENTORYTABLECONFIGURATIONRESULT_SCHEMA_ID,
  121    121   
    ::aws_smithy_schema::ShapeType::Structure,
  122    122   
    &[
  123    123   
        &INVENTORYTABLECONFIGURATIONRESULT_MEMBER_CONFIGURATION_STATE,
  124    124   
        &INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_STATUS,
  125    125   
        &INVENTORYTABLECONFIGURATIONRESULT_MEMBER_ERROR,
  126    126   
        &INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_NAME,
  127    127   
        &INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_ARN,
  128    128   
    ],
  129    129   
);
  130    130   
impl InventoryTableConfigurationResult {
  131    131   
    /// The schema for this shape.
  132    132   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVENTORYTABLECONFIGURATIONRESULT_SCHEMA;
  133    133   
}
  134    134   
impl ::aws_smithy_schema::serde::SerializableStruct for InventoryTableConfigurationResult {
  135    135   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  136    136   
    fn serialize_members(
  137    137   
        &self,
  138    138   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  139    139   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  140    140   
        {
  141    141   
            let val = &self.configuration_state;
  142    142   
            ser.write_string(&INVENTORYTABLECONFIGURATIONRESULT_MEMBER_CONFIGURATION_STATE, val.as_str())?;
  143    143   
        }
  144    144   
        if let Some(ref val) = self.table_status {
  145    145   
            ser.write_string(&INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_STATUS, val)?;
  146    146   
        }
  147    147   
        if let Some(ref val) = self.error {
  148    148   
            ser.write_struct(&INVENTORYTABLECONFIGURATIONRESULT_MEMBER_ERROR, val)?;
  149    149   
        }
  150    150   
        if let Some(ref val) = self.table_name {
  151    151   
            ser.write_string(&INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_NAME, val)?;
  152    152   
        }
  153    153   
        if let Some(ref val) = self.table_arn {
  154    154   
            ser.write_string(&INVENTORYTABLECONFIGURATIONRESULT_MEMBER_TABLE_ARN, val)?;
  155    155   
        }
  156    156   
        Ok(())
  157    157   
    }
  158    158   
}
  159    159   
impl InventoryTableConfigurationResult {
  160    160   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  161         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  162         -
        deserializer: &mut D,
         161  +
    pub fn deserialize(
         162  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  163    163   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  164    164   
        #[allow(unused_variables, unused_mut)]
  165    165   
        let mut builder = Self::builder();
  166    166   
        #[allow(
  167    167   
            unused_variables,
  168    168   
            unreachable_code,
  169    169   
            clippy::single_match,
  170    170   
            clippy::match_single_binding,
  171    171   
            clippy::diverging_sub_expression
  172    172   
        )]
  173         -
        deserializer.read_struct(&INVENTORYTABLECONFIGURATIONRESULT_SCHEMA, (), |_, member, deser| {
         173  +
        deserializer.read_struct(&INVENTORYTABLECONFIGURATIONRESULT_SCHEMA, &mut |member, deser| {
  174    174   
            match member.member_index() {
  175    175   
                Some(0) => {
  176    176   
                    builder.configuration_state = Some(crate::types::InventoryConfigurationState::from(deser.read_string(member)?.as_str()));
  177    177   
                }
  178    178   
                Some(1) => {
  179    179   
                    builder.table_status = Some(deser.read_string(member)?);
  180    180   
                }
  181    181   
                Some(2) => {
  182    182   
                    builder.error = Some(crate::types::ErrorDetails::deserialize(deser)?);
  183    183   
                }
  184    184   
                Some(3) => {
  185    185   
                    builder.table_name = Some(deser.read_string(member)?);
  186    186   
                }
  187    187   
                Some(4) => {
  188    188   
                    builder.table_arn = Some(deser.read_string(member)?);
  189    189   
                }
  190    190   
                _ => {}
  191    191   
            }
  192    192   
            Ok(())
  193    193   
        })?;
  194    194   
        builder
  195    195   
            .build()
  196    196   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  197    197   
    }
  198    198   
}
         199  +
impl InventoryTableConfigurationResult {
         200  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         201  +
    pub fn deserialize_with_response(
         202  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         203  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         204  +
        _status: u16,
         205  +
        _body: &[u8],
         206  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         207  +
        Self::deserialize(deserializer)
         208  +
    }
         209  +
}
  199    210   
impl InventoryTableConfigurationResult {
  200    211   
    /// Creates a new builder-style object to manufacture [`InventoryTableConfigurationResult`](crate::types::InventoryTableConfigurationResult).
  201    212   
    pub fn builder() -> crate::types::builders::InventoryTableConfigurationResultBuilder {
  202    213   
        crate::types::builders::InventoryTableConfigurationResultBuilder::default()
  203    214   
    }
  204    215   
}
  205    216   
  206    217   
/// A builder for [`InventoryTableConfigurationResult`](crate::types::InventoryTableConfigurationResult).
  207    218   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  208    219   
#[non_exhaustive]

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

@@ -4,4 +135,146 @@
   24     24   
    "com.amazonaws.s3",
   25     25   
    "InventoryTableConfigurationUpdates",
   26     26   
);
   27     27   
static INVENTORYTABLECONFIGURATIONUPDATES_MEMBER_CONFIGURATION_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.s3#InventoryTableConfigurationUpdates$ConfigurationState",
   30     30   
        "com.amazonaws.s3",
   31     31   
        "InventoryTableConfigurationUpdates",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "configuration_state",
          34  +
    "ConfigurationState",
   35     35   
    0,
   36     36   
);
   37     37   
static INVENTORYTABLECONFIGURATIONUPDATES_MEMBER_ENCRYPTION_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.s3#InventoryTableConfigurationUpdates$EncryptionConfiguration",
   40     40   
        "com.amazonaws.s3",
   41     41   
        "InventoryTableConfigurationUpdates",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Structure,
   44         -
    "encryption_configuration",
          44  +
    "EncryptionConfiguration",
   45     45   
    1,
   46     46   
);
   47     47   
static INVENTORYTABLECONFIGURATIONUPDATES_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    INVENTORYTABLECONFIGURATIONUPDATES_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[
   51     51   
        &INVENTORYTABLECONFIGURATIONUPDATES_MEMBER_CONFIGURATION_STATE,
   52     52   
        &INVENTORYTABLECONFIGURATIONUPDATES_MEMBER_ENCRYPTION_CONFIGURATION,
   53     53   
    ],
   54     54   
);
   55     55   
impl InventoryTableConfigurationUpdates {
   56     56   
    /// The schema for this shape.
   57     57   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVENTORYTABLECONFIGURATIONUPDATES_SCHEMA;
   58     58   
}
   59     59   
impl ::aws_smithy_schema::serde::SerializableStruct for InventoryTableConfigurationUpdates {
   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.configuration_state;
   67     67   
            ser.write_string(&INVENTORYTABLECONFIGURATIONUPDATES_MEMBER_CONFIGURATION_STATE, val.as_str())?;
   68     68   
        }
   69     69   
        if let Some(ref val) = self.encryption_configuration {
   70     70   
            ser.write_struct(&INVENTORYTABLECONFIGURATIONUPDATES_MEMBER_ENCRYPTION_CONFIGURATION, val)?;
   71     71   
        }
   72     72   
        Ok(())
   73     73   
    }
   74     74   
}
   75     75   
impl InventoryTableConfigurationUpdates {
   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(&INVENTORYTABLECONFIGURATIONUPDATES_SCHEMA, (), |_, member, deser| {
          89  +
        deserializer.read_struct(&INVENTORYTABLECONFIGURATIONUPDATES_SCHEMA, &mut |member, deser| {
   90     90   
            match member.member_index() {
   91     91   
                Some(0) => {
   92     92   
                    builder.configuration_state = Some(crate::types::InventoryConfigurationState::from(deser.read_string(member)?.as_str()));
   93     93   
                }
   94     94   
                Some(1) => {
   95     95   
                    builder.encryption_configuration = Some(crate::types::MetadataTableEncryptionConfiguration::deserialize(deser)?);
   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 InventoryTableConfigurationUpdates {
         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 InventoryTableConfigurationUpdates {
  107    118   
    /// Creates a new builder-style object to manufacture [`InventoryTableConfigurationUpdates`](crate::types::InventoryTableConfigurationUpdates).
  108    119   
    pub fn builder() -> crate::types::builders::InventoryTableConfigurationUpdatesBuilder {
  109    120   
        crate::types::builders::InventoryTableConfigurationUpdatesBuilder::default()
  110    121   
    }
  111    122   
}
  112    123   
  113    124   
/// A builder for [`InventoryTableConfigurationUpdates`](crate::types::InventoryTableConfigurationUpdates).
  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/_journal_table_configuration.rs

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

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

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

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

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

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

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

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

@@ -1,1 +100,111 @@
   11     11   
    /// <p>The value used to separate individual records in the output. If no value is specified, Amazon S3 uses a newline character ('\n').</p>
   12     12   
    pub fn record_delimiter(&self) -> ::std::option::Option<&str> {
   13     13   
        self.record_delimiter.as_deref()
   14     14   
    }
   15     15   
}
   16     16   
static JSONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#JSONOutput", "com.amazonaws.s3", "JSONOutput");
   18     18   
static JSONOUTPUT_MEMBER_RECORD_DELIMITER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#JSONOutput$RecordDelimiter", "com.amazonaws.s3", "JSONOutput"),
   20     20   
    ::aws_smithy_schema::ShapeType::String,
   21         -
    "record_delimiter",
          21  +
    "RecordDelimiter",
   22     22   
    0,
   23     23   
);
   24     24   
static JSONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   25     25   
    JSONOUTPUT_SCHEMA_ID,
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    &[&JSONOUTPUT_MEMBER_RECORD_DELIMITER],
   28     28   
);
   29     29   
impl JsonOutput {
   30     30   
    /// The schema for this shape.
   31     31   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &JSONOUTPUT_SCHEMA;
   32     32   
}
   33     33   
impl ::aws_smithy_schema::serde::SerializableStruct for JsonOutput {
   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.record_delimiter {
   40     40   
            ser.write_string(&JSONOUTPUT_MEMBER_RECORD_DELIMITER, val)?;
   41     41   
        }
   42     42   
        Ok(())
   43     43   
    }
   44     44   
}
   45     45   
impl JsonOutput {
   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(&JSONOUTPUT_SCHEMA, (), |_, member, deser| {
          59  +
        deserializer.read_struct(&JSONOUTPUT_SCHEMA, &mut |member, deser| {
   60     60   
            match member.member_index() {
   61     61   
                Some(0) => {
   62     62   
                    builder.record_delimiter = Some(deser.read_string(member)?);
   63     63   
                }
   64     64   
                _ => {}
   65     65   
            }
   66     66   
            Ok(())
   67     67   
        })?;
   68     68   
        Ok(builder.build())
   69     69   
    }
   70     70   
}
          71  +
impl JsonOutput {
          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 JsonOutput {
   72     83   
    /// Creates a new builder-style object to manufacture [`JsonOutput`](crate::types::JsonOutput).
   73     84   
    pub fn builder() -> crate::types::builders::JsonOutputBuilder {
   74     85   
        crate::types::builders::JsonOutputBuilder::default()
   75     86   
    }
   76     87   
}
   77     88   
   78     89   
/// A builder for [`JsonOutput`](crate::types::JsonOutput).
   79     90   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   80     91   
#[non_exhaustive]

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

@@ -18,18 +206,216 @@
   38     38   
    "com.amazonaws.s3",
   39     39   
    "LambdaFunctionConfiguration",
   40     40   
);
   41     41   
static LAMBDAFUNCTIONCONFIGURATION_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   42     42   
    ::aws_smithy_schema::ShapeId::from_static(
   43     43   
        "com.amazonaws.s3#LambdaFunctionConfiguration$Id",
   44     44   
        "com.amazonaws.s3",
   45     45   
        "LambdaFunctionConfiguration",
   46     46   
    ),
   47     47   
    ::aws_smithy_schema::ShapeType::String,
   48         -
    "id",
          48  +
    "Id",
   49     49   
    0,
   50     50   
);
   51     51   
static LAMBDAFUNCTIONCONFIGURATION_MEMBER_LAMBDA_FUNCTION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.s3#LambdaFunctionConfiguration$LambdaFunctionArn",
   54     54   
        "com.amazonaws.s3",
   55     55   
        "LambdaFunctionConfiguration",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::String,
   58         -
    "lambda_function_arn",
          58  +
    "LambdaFunctionArn",
   59     59   
    1,
   60     60   
)
   61     61   
.with_xml_name("CloudFunction");
   62     62   
static LAMBDAFUNCTIONCONFIGURATION_MEMBER_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.s3#LambdaFunctionConfiguration$Events",
   65     65   
        "com.amazonaws.s3",
   66     66   
        "LambdaFunctionConfiguration",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::List,
   69         -
    "events",
          69  +
    "Events",
   70     70   
    2,
   71     71   
)
   72     72   
.with_xml_name("Event")
   73     73   
.with_xml_flattened();
   74     74   
static LAMBDAFUNCTIONCONFIGURATION_MEMBER_FILTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "com.amazonaws.s3#LambdaFunctionConfiguration$Filter",
   77     77   
        "com.amazonaws.s3",
   78     78   
        "LambdaFunctionConfiguration",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::Structure,
   81         -
    "filter",
          81  +
    "Filter",
   82     82   
    3,
   83     83   
);
   84     84   
static LAMBDAFUNCTIONCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   85     85   
    LAMBDAFUNCTIONCONFIGURATION_SCHEMA_ID,
   86     86   
    ::aws_smithy_schema::ShapeType::Structure,
   87     87   
    &[
   88     88   
        &LAMBDAFUNCTIONCONFIGURATION_MEMBER_ID,
   89     89   
        &LAMBDAFUNCTIONCONFIGURATION_MEMBER_LAMBDA_FUNCTION_ARN,
   90     90   
        &LAMBDAFUNCTIONCONFIGURATION_MEMBER_EVENTS,
   91     91   
        &LAMBDAFUNCTIONCONFIGURATION_MEMBER_FILTER,
   92     92   
    ],
   93     93   
);
   94     94   
impl LambdaFunctionConfiguration {
   95     95   
    /// The schema for this shape.
   96     96   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LAMBDAFUNCTIONCONFIGURATION_SCHEMA;
   97     97   
}
   98     98   
impl ::aws_smithy_schema::serde::SerializableStruct for LambdaFunctionConfiguration {
   99     99   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  100    100   
    fn serialize_members(
  101    101   
        &self,
  102    102   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  103    103   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  104    104   
        if let Some(ref val) = self.id {
  105    105   
            ser.write_string(&LAMBDAFUNCTIONCONFIGURATION_MEMBER_ID, val)?;
  106    106   
        }
  107    107   
        {
  108    108   
            let val = &self.lambda_function_arn;
  109    109   
            ser.write_string(&LAMBDAFUNCTIONCONFIGURATION_MEMBER_LAMBDA_FUNCTION_ARN, val)?;
  110    110   
        }
  111    111   
        {
  112    112   
            let val = &self.events;
  113    113   
  114    114   
            ser.write_list(
  115    115   
                &LAMBDAFUNCTIONCONFIGURATION_MEMBER_EVENTS,
  116    116   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  117    117   
                    for item in val {
  118    118   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
  119    119   
                    }
  120    120   
                    Ok(())
  121    121   
                },
  122    122   
            )?;
  123    123   
        }
  124    124   
        if let Some(ref val) = self.filter {
  125    125   
            ser.write_struct(&LAMBDAFUNCTIONCONFIGURATION_MEMBER_FILTER, val)?;
  126    126   
        }
  127    127   
        Ok(())
  128    128   
    }
  129    129   
}
  130    130   
impl LambdaFunctionConfiguration {
  131    131   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  132         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  133         -
        deserializer: &mut D,
         132  +
    pub fn deserialize(
         133  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  134    134   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  135    135   
        #[allow(unused_variables, unused_mut)]
  136    136   
        let mut builder = Self::builder();
  137    137   
        #[allow(
  138    138   
            unused_variables,
  139    139   
            unreachable_code,
  140    140   
            clippy::single_match,
  141    141   
            clippy::match_single_binding,
  142    142   
            clippy::diverging_sub_expression
  143    143   
        )]
  144         -
        deserializer.read_struct(&LAMBDAFUNCTIONCONFIGURATION_SCHEMA, (), |_, member, deser| {
         144  +
        deserializer.read_struct(&LAMBDAFUNCTIONCONFIGURATION_SCHEMA, &mut |member, deser| {
  145    145   
            match member.member_index() {
  146    146   
                Some(0) => {
  147    147   
                    builder.id = Some(deser.read_string(member)?);
  148    148   
                }
  149    149   
                Some(1) => {
  150    150   
                    builder.lambda_function_arn = Some(deser.read_string(member)?);
  151    151   
                }
  152    152   
                Some(2) => {
  153    153   
                    builder.events = Some({
  154         -
                        let container = if let Some(cap) = deser.container_size() {
  155         -
                            Vec::with_capacity(cap)
  156         -
                        } else {
  157         -
                            Vec::new()
  158         -
                        };
  159         -
                        deser.read_list(member, container, |mut list, deser| {
  160         -
                            list.push(crate::types::Event::from(deser.read_string(member)?.as_str()));
  161         -
                            Ok(list)
  162         -
                        })?
         154  +
                        let mut container = Vec::new();
         155  +
                        deser.read_list(member, &mut |deser| {
         156  +
                            container.push(crate::types::Event::from(deser.read_string(member)?.as_str()));
         157  +
                            Ok(())
         158  +
                        })?;
         159  +
                        container
  163    160   
                    });
  164    161   
                }
  165    162   
                Some(3) => {
  166    163   
                    builder.filter = Some(crate::types::NotificationConfigurationFilter::deserialize(deser)?);
  167    164   
                }
  168    165   
                _ => {}
  169    166   
            }
  170    167   
            Ok(())
  171    168   
        })?;
         169  +
        builder.lambda_function_arn = builder.lambda_function_arn.or(Some(String::new()));
         170  +
        builder.events = builder.events.or(Some(Vec::new()));
  172    171   
        builder
  173    172   
            .build()
  174    173   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  175    174   
    }
  176    175   
}
         176  +
impl LambdaFunctionConfiguration {
         177  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         178  +
    pub fn deserialize_with_response(
         179  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         180  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         181  +
        _status: u16,
         182  +
        _body: &[u8],
         183  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         184  +
        Self::deserialize(deserializer)
         185  +
    }
         186  +
}
  177    187   
impl LambdaFunctionConfiguration {
  178    188   
    /// Creates a new builder-style object to manufacture [`LambdaFunctionConfiguration`](crate::types::LambdaFunctionConfiguration).
  179    189   
    pub fn builder() -> crate::types::builders::LambdaFunctionConfigurationBuilder {
  180    190   
        crate::types::builders::LambdaFunctionConfigurationBuilder::default()
  181    191   
    }
  182    192   
}
  183    193   
  184    194   
/// A builder for [`LambdaFunctionConfiguration`](crate::types::LambdaFunctionConfiguration).
  185    195   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  186    196   
#[non_exhaustive]

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

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

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

@@ -68,68 +192,192 @@
   88     88   
    /// <p>Specifies the days since the initiation of an incomplete multipart upload that Amazon S3 will wait before permanently removing all parts of the upload. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config"> Aborting Incomplete Multipart Uploads Using a Bucket Lifecycle Configuration</a> in the <i>Amazon S3 User Guide</i>.</p>
   89     89   
    pub fn abort_incomplete_multipart_upload(&self) -> ::std::option::Option<&crate::types::AbortIncompleteMultipartUpload> {
   90     90   
        self.abort_incomplete_multipart_upload.as_ref()
   91     91   
    }
   92     92   
}
   93     93   
static LIFECYCLERULE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   94     94   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LifecycleRule", "com.amazonaws.s3", "LifecycleRule");
   95     95   
static LIFECYCLERULE_MEMBER_EXPIRATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LifecycleRule$Expiration", "com.amazonaws.s3", "LifecycleRule"),
   97     97   
    ::aws_smithy_schema::ShapeType::Structure,
   98         -
    "expiration",
          98  +
    "Expiration",
   99     99   
    0,
  100    100   
);
  101    101   
static LIFECYCLERULE_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LifecycleRule$ID", "com.amazonaws.s3", "LifecycleRule"),
  103    103   
    ::aws_smithy_schema::ShapeType::String,
  104         -
    "id",
         104  +
    "ID",
  105    105   
    1,
  106    106   
);
  107    107   
static LIFECYCLERULE_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LifecycleRule$Prefix", "com.amazonaws.s3", "LifecycleRule"),
  109    109   
    ::aws_smithy_schema::ShapeType::String,
  110         -
    "prefix",
         110  +
    "Prefix",
  111    111   
    2,
  112    112   
);
  113    113   
static LIFECYCLERULE_MEMBER_FILTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LifecycleRule$Filter", "com.amazonaws.s3", "LifecycleRule"),
  115    115   
    ::aws_smithy_schema::ShapeType::Structure,
  116         -
    "filter",
         116  +
    "Filter",
  117    117   
    3,
  118    118   
);
  119    119   
static LIFECYCLERULE_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LifecycleRule$Status", "com.amazonaws.s3", "LifecycleRule"),
  121    121   
    ::aws_smithy_schema::ShapeType::String,
  122         -
    "status",
         122  +
    "Status",
  123    123   
    4,
  124    124   
);
  125    125   
static LIFECYCLERULE_MEMBER_TRANSITIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LifecycleRule$Transitions", "com.amazonaws.s3", "LifecycleRule"),
  127    127   
    ::aws_smithy_schema::ShapeType::List,
  128         -
    "transitions",
         128  +
    "Transitions",
  129    129   
    5,
  130    130   
)
  131    131   
.with_xml_name("Transition")
  132    132   
.with_xml_flattened();
  133    133   
static LIFECYCLERULE_MEMBER_NONCURRENT_VERSION_TRANSITIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  134    134   
    ::aws_smithy_schema::ShapeId::from_static(
  135    135   
        "com.amazonaws.s3#LifecycleRule$NoncurrentVersionTransitions",
  136    136   
        "com.amazonaws.s3",
  137    137   
        "LifecycleRule",
  138    138   
    ),
  139    139   
    ::aws_smithy_schema::ShapeType::List,
  140         -
    "noncurrent_version_transitions",
         140  +
    "NoncurrentVersionTransitions",
  141    141   
    6,
  142    142   
)
  143    143   
.with_xml_name("NoncurrentVersionTransition")
  144    144   
.with_xml_flattened();
  145    145   
static LIFECYCLERULE_MEMBER_NONCURRENT_VERSION_EXPIRATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static(
  147    147   
        "com.amazonaws.s3#LifecycleRule$NoncurrentVersionExpiration",
  148    148   
        "com.amazonaws.s3",
  149    149   
        "LifecycleRule",
  150    150   
    ),
  151    151   
    ::aws_smithy_schema::ShapeType::Structure,
  152         -
    "noncurrent_version_expiration",
         152  +
    "NoncurrentVersionExpiration",
  153    153   
    7,
  154    154   
);
  155    155   
static LIFECYCLERULE_MEMBER_ABORT_INCOMPLETE_MULTIPART_UPLOAD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  156    156   
    ::aws_smithy_schema::ShapeId::from_static(
  157    157   
        "com.amazonaws.s3#LifecycleRule$AbortIncompleteMultipartUpload",
  158    158   
        "com.amazonaws.s3",
  159    159   
        "LifecycleRule",
  160    160   
    ),
  161    161   
    ::aws_smithy_schema::ShapeType::Structure,
  162         -
    "abort_incomplete_multipart_upload",
         162  +
    "AbortIncompleteMultipartUpload",
  163    163   
    8,
  164    164   
);
  165    165   
static LIFECYCLERULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  166    166   
    LIFECYCLERULE_SCHEMA_ID,
  167    167   
    ::aws_smithy_schema::ShapeType::Structure,
  168    168   
    &[
  169    169   
        &LIFECYCLERULE_MEMBER_EXPIRATION,
  170    170   
        &LIFECYCLERULE_MEMBER_ID,
  171    171   
        &LIFECYCLERULE_MEMBER_PREFIX,
  172    172   
        &LIFECYCLERULE_MEMBER_FILTER,
@@ -209,209 +338,343 @@
  229    229   
            ser.write_struct(&LIFECYCLERULE_MEMBER_NONCURRENT_VERSION_EXPIRATION, val)?;
  230    230   
        }
  231    231   
        if let Some(ref val) = self.abort_incomplete_multipart_upload {
  232    232   
            ser.write_struct(&LIFECYCLERULE_MEMBER_ABORT_INCOMPLETE_MULTIPART_UPLOAD, val)?;
  233    233   
        }
  234    234   
        Ok(())
  235    235   
    }
  236    236   
}
  237    237   
impl LifecycleRule {
  238    238   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  239         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  240         -
        deserializer: &mut D,
         239  +
    pub fn deserialize(
         240  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  241    241   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  242    242   
        #[allow(unused_variables, unused_mut)]
  243    243   
        let mut builder = Self::builder();
  244    244   
        #[allow(
  245    245   
            unused_variables,
  246    246   
            unreachable_code,
  247    247   
            clippy::single_match,
  248    248   
            clippy::match_single_binding,
  249    249   
            clippy::diverging_sub_expression
  250    250   
        )]
  251         -
        deserializer.read_struct(&LIFECYCLERULE_SCHEMA, (), |_, member, deser| {
         251  +
        deserializer.read_struct(&LIFECYCLERULE_SCHEMA, &mut |member, deser| {
  252    252   
            match member.member_index() {
  253    253   
                Some(0) => {
  254    254   
                    builder.expiration = Some(crate::types::LifecycleExpiration::deserialize(deser)?);
  255    255   
                }
  256    256   
                Some(1) => {
  257    257   
                    builder.id = Some(deser.read_string(member)?);
  258    258   
                }
  259    259   
                Some(2) => {
  260    260   
                    builder.prefix = Some(deser.read_string(member)?);
  261    261   
                }
  262    262   
                Some(3) => {
  263    263   
                    builder.filter = Some(crate::types::LifecycleRuleFilter::deserialize(deser)?);
  264    264   
                }
  265    265   
                Some(4) => {
  266    266   
                    builder.status = Some(crate::types::ExpirationStatus::from(deser.read_string(member)?.as_str()));
  267    267   
                }
  268    268   
                Some(5) => {
  269    269   
                    builder.transitions = Some({
  270         -
                        let container = if let Some(cap) = deser.container_size() {
  271         -
                            Vec::with_capacity(cap)
  272         -
                        } else {
  273         -
                            Vec::new()
  274         -
                        };
  275         -
                        deser.read_list(member, container, |mut list, deser| {
  276         -
                            list.push(crate::types::Transition::deserialize(deser)?);
  277         -
                            Ok(list)
  278         -
                        })?
         270  +
                        let mut container = Vec::new();
         271  +
                        deser.read_list(member, &mut |deser| {
         272  +
                            container.push(crate::types::Transition::deserialize(deser)?);
         273  +
                            Ok(())
         274  +
                        })?;
         275  +
                        container
  279    276   
                    });
  280    277   
                }
  281    278   
                Some(6) => {
  282    279   
                    builder.noncurrent_version_transitions = Some({
  283         -
                        let container = if let Some(cap) = deser.container_size() {
  284         -
                            Vec::with_capacity(cap)
  285         -
                        } else {
  286         -
                            Vec::new()
  287         -
                        };
  288         -
                        deser.read_list(member, container, |mut list, deser| {
  289         -
                            list.push(crate::types::NoncurrentVersionTransition::deserialize(deser)?);
  290         -
                            Ok(list)
  291         -
                        })?
         280  +
                        let mut container = Vec::new();
         281  +
                        deser.read_list(member, &mut |deser| {
         282  +
                            container.push(crate::types::NoncurrentVersionTransition::deserialize(deser)?);
         283  +
                            Ok(())
         284  +
                        })?;
         285  +
                        container
  292    286   
                    });
  293    287   
                }
  294    288   
                Some(7) => {
  295    289   
                    builder.noncurrent_version_expiration = Some(crate::types::NoncurrentVersionExpiration::deserialize(deser)?);
  296    290   
                }
  297    291   
                Some(8) => {
  298    292   
                    builder.abort_incomplete_multipart_upload = Some(crate::types::AbortIncompleteMultipartUpload::deserialize(deser)?);
  299    293   
                }
  300    294   
                _ => {}
  301    295   
            }
  302    296   
            Ok(())
  303    297   
        })?;
  304    298   
        builder
  305    299   
            .build()
  306    300   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  307    301   
    }
  308    302   
}
         303  +
impl LifecycleRule {
         304  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         305  +
    pub fn deserialize_with_response(
         306  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         307  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         308  +
        _status: u16,
         309  +
        _body: &[u8],
         310  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         311  +
        Self::deserialize(deserializer)
         312  +
    }
         313  +
}
  309    314   
impl LifecycleRule {
  310    315   
    /// Creates a new builder-style object to manufacture [`LifecycleRule`](crate::types::LifecycleRule).
  311    316   
    pub fn builder() -> crate::types::builders::LifecycleRuleBuilder {
  312    317   
        crate::types::builders::LifecycleRuleBuilder::default()
  313    318   
    }
  314    319   
}
  315    320   
  316    321   
/// A builder for [`LifecycleRule`](crate::types::LifecycleRule).
  317    322   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  318    323   
#[non_exhaustive]

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

@@ -18,18 +200,208 @@
   38     38   
    "com.amazonaws.s3",
   39     39   
    "LifecycleRuleAndOperator",
   40     40   
);
   41     41   
static LIFECYCLERULEANDOPERATOR_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   42     42   
    ::aws_smithy_schema::ShapeId::from_static(
   43     43   
        "com.amazonaws.s3#LifecycleRuleAndOperator$Prefix",
   44     44   
        "com.amazonaws.s3",
   45     45   
        "LifecycleRuleAndOperator",
   46     46   
    ),
   47     47   
    ::aws_smithy_schema::ShapeType::String,
   48         -
    "prefix",
          48  +
    "Prefix",
   49     49   
    0,
   50     50   
);
   51     51   
static LIFECYCLERULEANDOPERATOR_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.s3#LifecycleRuleAndOperator$Tags",
   54     54   
        "com.amazonaws.s3",
   55     55   
        "LifecycleRuleAndOperator",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::List,
   58         -
    "tags",
          58  +
    "Tags",
   59     59   
    1,
   60     60   
)
   61     61   
.with_xml_name("Tag")
   62     62   
.with_xml_flattened();
   63     63   
static LIFECYCLERULEANDOPERATOR_MEMBER_OBJECT_SIZE_GREATER_THAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.s3#LifecycleRuleAndOperator$ObjectSizeGreaterThan",
   66     66   
        "com.amazonaws.s3",
   67     67   
        "LifecycleRuleAndOperator",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::Long,
   70         -
    "object_size_greater_than",
          70  +
    "ObjectSizeGreaterThan",
   71     71   
    2,
   72     72   
);
   73     73   
static LIFECYCLERULEANDOPERATOR_MEMBER_OBJECT_SIZE_LESS_THAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.s3#LifecycleRuleAndOperator$ObjectSizeLessThan",
   76     76   
        "com.amazonaws.s3",
   77     77   
        "LifecycleRuleAndOperator",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::Long,
   80         -
    "object_size_less_than",
          80  +
    "ObjectSizeLessThan",
   81     81   
    3,
   82     82   
);
   83     83   
static LIFECYCLERULEANDOPERATOR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   84     84   
    LIFECYCLERULEANDOPERATOR_SCHEMA_ID,
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86     86   
    &[
   87     87   
        &LIFECYCLERULEANDOPERATOR_MEMBER_PREFIX,
   88     88   
        &LIFECYCLERULEANDOPERATOR_MEMBER_TAGS,
   89     89   
        &LIFECYCLERULEANDOPERATOR_MEMBER_OBJECT_SIZE_GREATER_THAN,
   90     90   
        &LIFECYCLERULEANDOPERATOR_MEMBER_OBJECT_SIZE_LESS_THAN,
   91     91   
    ],
   92     92   
);
   93     93   
impl LifecycleRuleAndOperator {
   94     94   
    /// The schema for this shape.
   95     95   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LIFECYCLERULEANDOPERATOR_SCHEMA;
   96     96   
}
   97     97   
impl ::aws_smithy_schema::serde::SerializableStruct for LifecycleRuleAndOperator {
   98     98   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   99     99   
    fn serialize_members(
  100    100   
        &self,
  101    101   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  102    102   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  103    103   
        if let Some(ref val) = self.prefix {
  104    104   
            ser.write_string(&LIFECYCLERULEANDOPERATOR_MEMBER_PREFIX, val)?;
  105    105   
        }
  106    106   
        if let Some(ref val) = self.tags {
  107    107   
            ser.write_list(
  108    108   
                &LIFECYCLERULEANDOPERATOR_MEMBER_TAGS,
  109    109   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  110    110   
                    for item in val {
  111    111   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  112    112   
                    }
  113    113   
                    Ok(())
  114    114   
                },
  115    115   
            )?;
  116    116   
        }
  117    117   
        if let Some(ref val) = self.object_size_greater_than {
  118    118   
            ser.write_long(&LIFECYCLERULEANDOPERATOR_MEMBER_OBJECT_SIZE_GREATER_THAN, *val)?;
  119    119   
        }
  120    120   
        if let Some(ref val) = self.object_size_less_than {
  121    121   
            ser.write_long(&LIFECYCLERULEANDOPERATOR_MEMBER_OBJECT_SIZE_LESS_THAN, *val)?;
  122    122   
        }
  123    123   
        Ok(())
  124    124   
    }
  125    125   
}
  126    126   
impl LifecycleRuleAndOperator {
  127    127   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  128         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  129         -
        deserializer: &mut D,
         128  +
    pub fn deserialize(
         129  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  130    130   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  131    131   
        #[allow(unused_variables, unused_mut)]
  132    132   
        let mut builder = Self::builder();
  133    133   
        #[allow(
  134    134   
            unused_variables,
  135    135   
            unreachable_code,
  136    136   
            clippy::single_match,
  137    137   
            clippy::match_single_binding,
  138    138   
            clippy::diverging_sub_expression
  139    139   
        )]
  140         -
        deserializer.read_struct(&LIFECYCLERULEANDOPERATOR_SCHEMA, (), |_, member, deser| {
         140  +
        deserializer.read_struct(&LIFECYCLERULEANDOPERATOR_SCHEMA, &mut |member, deser| {
  141    141   
            match member.member_index() {
  142    142   
                Some(0) => {
  143    143   
                    builder.prefix = Some(deser.read_string(member)?);
  144    144   
                }
  145    145   
                Some(1) => {
  146    146   
                    builder.tags = Some({
  147         -
                        let container = if let Some(cap) = deser.container_size() {
  148         -
                            Vec::with_capacity(cap)
  149         -
                        } else {
  150         -
                            Vec::new()
  151         -
                        };
  152         -
                        deser.read_list(member, container, |mut list, deser| {
  153         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  154         -
                            Ok(list)
  155         -
                        })?
         147  +
                        let mut container = Vec::new();
         148  +
                        deser.read_list(member, &mut |deser| {
         149  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         150  +
                            Ok(())
         151  +
                        })?;
         152  +
                        container
  156    153   
                    });
  157    154   
                }
  158    155   
                Some(2) => {
  159    156   
                    builder.object_size_greater_than = Some(deser.read_long(member)?);
  160    157   
                }
  161    158   
                Some(3) => {
  162    159   
                    builder.object_size_less_than = Some(deser.read_long(member)?);
  163    160   
                }
  164    161   
                _ => {}
  165    162   
            }
  166    163   
            Ok(())
  167    164   
        })?;
  168    165   
        Ok(builder.build())
  169    166   
    }
  170    167   
}
         168  +
impl LifecycleRuleAndOperator {
         169  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         170  +
    pub fn deserialize_with_response(
         171  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         172  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         173  +
        _status: u16,
         174  +
        _body: &[u8],
         175  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         176  +
        Self::deserialize(deserializer)
         177  +
    }
         178  +
}
  171    179   
impl LifecycleRuleAndOperator {
  172    180   
    /// Creates a new builder-style object to manufacture [`LifecycleRuleAndOperator`](crate::types::LifecycleRuleAndOperator).
  173    181   
    pub fn builder() -> crate::types::builders::LifecycleRuleAndOperatorBuilder {
  174    182   
        crate::types::builders::LifecycleRuleAndOperatorBuilder::default()
  175    183   
    }
  176    184   
}
  177    185   
  178    186   
/// A builder for [`LifecycleRuleAndOperator`](crate::types::LifecycleRuleAndOperator).
  179    187   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  180    188   
#[non_exhaustive]

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

@@ -23,23 +194,205 @@
   43     43   
    /// <p>This is used in a Lifecycle Rule Filter to apply a logical AND to two or more predicates. The Lifecycle Rule will apply to any object matching all of the predicates configured inside the And operator.</p>
   44     44   
    pub fn and(&self) -> ::std::option::Option<&crate::types::LifecycleRuleAndOperator> {
   45     45   
        self.and.as_ref()
   46     46   
    }
   47     47   
}
   48     48   
static LIFECYCLERULEFILTER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LifecycleRuleFilter", "com.amazonaws.s3", "LifecycleRuleFilter");
   50     50   
static LIFECYCLERULEFILTER_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LifecycleRuleFilter$Prefix", "com.amazonaws.s3", "LifecycleRuleFilter"),
   52     52   
    ::aws_smithy_schema::ShapeType::String,
   53         -
    "prefix",
          53  +
    "Prefix",
   54     54   
    0,
   55     55   
);
   56     56   
static LIFECYCLERULEFILTER_MEMBER_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LifecycleRuleFilter$Tag", "com.amazonaws.s3", "LifecycleRuleFilter"),
   58     58   
    ::aws_smithy_schema::ShapeType::Structure,
   59         -
    "tag",
          59  +
    "Tag",
   60     60   
    1,
   61     61   
);
   62     62   
static LIFECYCLERULEFILTER_MEMBER_OBJECT_SIZE_GREATER_THAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.s3#LifecycleRuleFilter$ObjectSizeGreaterThan",
   65     65   
        "com.amazonaws.s3",
   66     66   
        "LifecycleRuleFilter",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::Long,
   69         -
    "object_size_greater_than",
          69  +
    "ObjectSizeGreaterThan",
   70     70   
    2,
   71     71   
);
   72     72   
static LIFECYCLERULEFILTER_MEMBER_OBJECT_SIZE_LESS_THAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.s3#LifecycleRuleFilter$ObjectSizeLessThan",
   75     75   
        "com.amazonaws.s3",
   76     76   
        "LifecycleRuleFilter",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::Long,
   79         -
    "object_size_less_than",
          79  +
    "ObjectSizeLessThan",
   80     80   
    3,
   81     81   
);
   82     82   
static LIFECYCLERULEFILTER_MEMBER_AND: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LifecycleRuleFilter$And", "com.amazonaws.s3", "LifecycleRuleFilter"),
   84     84   
    ::aws_smithy_schema::ShapeType::Structure,
   85         -
    "and",
          85  +
    "And",
   86     86   
    4,
   87     87   
);
   88     88   
static LIFECYCLERULEFILTER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   89     89   
    LIFECYCLERULEFILTER_SCHEMA_ID,
   90     90   
    ::aws_smithy_schema::ShapeType::Structure,
   91     91   
    &[
   92     92   
        &LIFECYCLERULEFILTER_MEMBER_PREFIX,
   93     93   
        &LIFECYCLERULEFILTER_MEMBER_TAG,
   94     94   
        &LIFECYCLERULEFILTER_MEMBER_OBJECT_SIZE_GREATER_THAN,
   95     95   
        &LIFECYCLERULEFILTER_MEMBER_OBJECT_SIZE_LESS_THAN,
   96     96   
        &LIFECYCLERULEFILTER_MEMBER_AND,
   97     97   
    ],
   98     98   
);
   99     99   
impl LifecycleRuleFilter {
  100    100   
    /// The schema for this shape.
  101    101   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LIFECYCLERULEFILTER_SCHEMA;
  102    102   
}
  103    103   
impl ::aws_smithy_schema::serde::SerializableStruct for LifecycleRuleFilter {
  104    104   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  105    105   
    fn serialize_members(
  106    106   
        &self,
  107    107   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  108    108   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  109    109   
        if let Some(ref val) = self.prefix {
  110    110   
            ser.write_string(&LIFECYCLERULEFILTER_MEMBER_PREFIX, val)?;
  111    111   
        }
  112    112   
        if let Some(ref val) = self.tag {
  113    113   
            ser.write_struct(&LIFECYCLERULEFILTER_MEMBER_TAG, val)?;
  114    114   
        }
  115    115   
        if let Some(ref val) = self.object_size_greater_than {
  116    116   
            ser.write_long(&LIFECYCLERULEFILTER_MEMBER_OBJECT_SIZE_GREATER_THAN, *val)?;
  117    117   
        }
  118    118   
        if let Some(ref val) = self.object_size_less_than {
  119    119   
            ser.write_long(&LIFECYCLERULEFILTER_MEMBER_OBJECT_SIZE_LESS_THAN, *val)?;
  120    120   
        }
  121    121   
        if let Some(ref val) = self.and {
  122    122   
            ser.write_struct(&LIFECYCLERULEFILTER_MEMBER_AND, val)?;
  123    123   
        }
  124    124   
        Ok(())
  125    125   
    }
  126    126   
}
  127    127   
impl LifecycleRuleFilter {
  128    128   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  129         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  130         -
        deserializer: &mut D,
         129  +
    pub fn deserialize(
         130  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  131    131   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  132    132   
        #[allow(unused_variables, unused_mut)]
  133    133   
        let mut builder = Self::builder();
  134    134   
        #[allow(
  135    135   
            unused_variables,
  136    136   
            unreachable_code,
  137    137   
            clippy::single_match,
  138    138   
            clippy::match_single_binding,
  139    139   
            clippy::diverging_sub_expression
  140    140   
        )]
  141         -
        deserializer.read_struct(&LIFECYCLERULEFILTER_SCHEMA, (), |_, member, deser| {
         141  +
        deserializer.read_struct(&LIFECYCLERULEFILTER_SCHEMA, &mut |member, deser| {
  142    142   
            match member.member_index() {
  143    143   
                Some(0) => {
  144    144   
                    builder.prefix = Some(deser.read_string(member)?);
  145    145   
                }
  146    146   
                Some(1) => {
  147    147   
                    builder.tag = Some(crate::types::Tag::deserialize(deser)?);
  148    148   
                }
  149    149   
                Some(2) => {
  150    150   
                    builder.object_size_greater_than = Some(deser.read_long(member)?);
  151    151   
                }
  152    152   
                Some(3) => {
  153    153   
                    builder.object_size_less_than = Some(deser.read_long(member)?);
  154    154   
                }
  155    155   
                Some(4) => {
  156    156   
                    builder.and = Some(crate::types::LifecycleRuleAndOperator::deserialize(deser)?);
  157    157   
                }
  158    158   
                _ => {}
  159    159   
            }
  160    160   
            Ok(())
  161    161   
        })?;
  162    162   
        Ok(builder.build())
  163    163   
    }
  164    164   
}
         165  +
impl LifecycleRuleFilter {
         166  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         167  +
    pub fn deserialize_with_response(
         168  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         169  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         170  +
        _status: u16,
         171  +
        _body: &[u8],
         172  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         173  +
        Self::deserialize(deserializer)
         174  +
    }
         175  +
}
  165    176   
impl LifecycleRuleFilter {
  166    177   
    /// Creates a new builder-style object to manufacture [`LifecycleRuleFilter`](crate::types::LifecycleRuleFilter).
  167    178   
    pub fn builder() -> crate::types::builders::LifecycleRuleFilterBuilder {
  168    179   
        crate::types::builders::LifecycleRuleFilterBuilder::default()
  169    180   
    }
  170    181   
}
  171    182   
  172    183   
/// A builder for [`LifecycleRuleFilter`](crate::types::LifecycleRuleFilter).
  173    184   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  174    185   
#[non_exhaustive]

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

@@ -2,2 +123,134 @@
   22     22   
    /// <p>For directory buckets, the name of the location is the Zone ID of the Availability Zone (AZ) or Local Zone (LZ) where the bucket will be created. An example AZ ID value is <code>usw2-az1</code>.</p>
   23     23   
    pub fn name(&self) -> ::std::option::Option<&str> {
   24     24   
        self.name.as_deref()
   25     25   
    }
   26     26   
}
   27     27   
static LOCATIONINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   28     28   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LocationInfo", "com.amazonaws.s3", "LocationInfo");
   29     29   
static LOCATIONINFO_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LocationInfo$Type", "com.amazonaws.s3", "LocationInfo"),
   31     31   
    ::aws_smithy_schema::ShapeType::String,
   32         -
    "r##type",
          32  +
    "Type",
   33     33   
    0,
   34     34   
);
   35     35   
static LOCATIONINFO_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   36     36   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LocationInfo$Name", "com.amazonaws.s3", "LocationInfo"),
   37     37   
    ::aws_smithy_schema::ShapeType::String,
   38         -
    "name",
          38  +
    "Name",
   39     39   
    1,
   40     40   
);
   41     41   
static LOCATIONINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   42     42   
    LOCATIONINFO_SCHEMA_ID,
   43     43   
    ::aws_smithy_schema::ShapeType::Structure,
   44     44   
    &[&LOCATIONINFO_MEMBER_TYPE, &LOCATIONINFO_MEMBER_NAME],
   45     45   
);
   46     46   
impl LocationInfo {
   47     47   
    /// The schema for this shape.
   48     48   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LOCATIONINFO_SCHEMA;
   49     49   
}
   50     50   
impl ::aws_smithy_schema::serde::SerializableStruct for LocationInfo {
   51     51   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   52     52   
    fn serialize_members(
   53     53   
        &self,
   54     54   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   55     55   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   56     56   
        if let Some(ref val) = self.r#type {
   57     57   
            ser.write_string(&LOCATIONINFO_MEMBER_TYPE, val.as_str())?;
   58     58   
        }
   59     59   
        if let Some(ref val) = self.name {
   60     60   
            ser.write_string(&LOCATIONINFO_MEMBER_NAME, val)?;
   61     61   
        }
   62     62   
        Ok(())
   63     63   
    }
   64     64   
}
   65     65   
impl LocationInfo {
   66     66   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   67         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   68         -
        deserializer: &mut D,
          67  +
    pub fn deserialize(
          68  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   69     69   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   70     70   
        #[allow(unused_variables, unused_mut)]
   71     71   
        let mut builder = Self::builder();
   72     72   
        #[allow(
   73     73   
            unused_variables,
   74     74   
            unreachable_code,
   75     75   
            clippy::single_match,
   76     76   
            clippy::match_single_binding,
   77     77   
            clippy::diverging_sub_expression
   78     78   
        )]
   79         -
        deserializer.read_struct(&LOCATIONINFO_SCHEMA, (), |_, member, deser| {
          79  +
        deserializer.read_struct(&LOCATIONINFO_SCHEMA, &mut |member, deser| {
   80     80   
            match member.member_index() {
   81     81   
                Some(0) => {
   82     82   
                    builder.r#type = Some(crate::types::LocationType::from(deser.read_string(member)?.as_str()));
   83     83   
                }
   84     84   
                Some(1) => {
   85     85   
                    builder.name = Some(deser.read_string(member)?);
   86     86   
                }
   87     87   
                _ => {}
   88     88   
            }
   89     89   
            Ok(())
   90     90   
        })?;
   91     91   
        Ok(builder.build())
   92     92   
    }
   93     93   
}
          94  +
impl LocationInfo {
          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  +
}
   94    105   
impl LocationInfo {
   95    106   
    /// Creates a new builder-style object to manufacture [`LocationInfo`](crate::types::LocationInfo).
   96    107   
    pub fn builder() -> crate::types::builders::LocationInfoBuilder {
   97    108   
        crate::types::builders::LocationInfoBuilder::default()
   98    109   
    }
   99    110   
}
  100    111   
  101    112   
/// A builder for [`LocationInfo`](crate::types::LocationInfo).
  102    113   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  103    114   
#[non_exhaustive]

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

@@ -15,15 +191,201 @@
   35     35   
    /// <p>Amazon S3 key format for log objects.</p>
   36     36   
    pub fn target_object_key_format(&self) -> ::std::option::Option<&crate::types::TargetObjectKeyFormat> {
   37     37   
        self.target_object_key_format.as_ref()
   38     38   
    }
   39     39   
}
   40     40   
static LOGGINGENABLED_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   41     41   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LoggingEnabled", "com.amazonaws.s3", "LoggingEnabled");
   42     42   
static LOGGINGENABLED_MEMBER_TARGET_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LoggingEnabled$TargetBucket", "com.amazonaws.s3", "LoggingEnabled"),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45         -
    "target_bucket",
          45  +
    "TargetBucket",
   46     46   
    0,
   47     47   
);
   48     48   
static LOGGINGENABLED_MEMBER_TARGET_GRANTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LoggingEnabled$TargetGrants", "com.amazonaws.s3", "LoggingEnabled"),
   50     50   
    ::aws_smithy_schema::ShapeType::List,
   51         -
    "target_grants",
          51  +
    "TargetGrants",
   52     52   
    1,
   53     53   
);
   54     54   
static LOGGINGENABLED_MEMBER_TARGET_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#LoggingEnabled$TargetPrefix", "com.amazonaws.s3", "LoggingEnabled"),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "target_prefix",
          57  +
    "TargetPrefix",
   58     58   
    2,
   59     59   
);
   60     60   
static LOGGINGENABLED_MEMBER_TARGET_OBJECT_KEY_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.s3#LoggingEnabled$TargetObjectKeyFormat",
   63     63   
        "com.amazonaws.s3",
   64     64   
        "LoggingEnabled",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::Structure,
   67         -
    "target_object_key_format",
          67  +
    "TargetObjectKeyFormat",
   68     68   
    3,
   69     69   
);
   70     70   
static LOGGINGENABLED_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   71     71   
    LOGGINGENABLED_SCHEMA_ID,
   72     72   
    ::aws_smithy_schema::ShapeType::Structure,
   73     73   
    &[
   74     74   
        &LOGGINGENABLED_MEMBER_TARGET_BUCKET,
   75     75   
        &LOGGINGENABLED_MEMBER_TARGET_GRANTS,
   76     76   
        &LOGGINGENABLED_MEMBER_TARGET_PREFIX,
   77     77   
        &LOGGINGENABLED_MEMBER_TARGET_OBJECT_KEY_FORMAT,
   78     78   
    ],
   79     79   
);
   80     80   
impl LoggingEnabled {
   81     81   
    /// The schema for this shape.
   82     82   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LOGGINGENABLED_SCHEMA;
   83     83   
}
   84     84   
impl ::aws_smithy_schema::serde::SerializableStruct for LoggingEnabled {
   85     85   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   86     86   
    fn serialize_members(
   87     87   
        &self,
   88     88   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   89     89   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   90     90   
        {
   91     91   
            let val = &self.target_bucket;
   92     92   
            ser.write_string(&LOGGINGENABLED_MEMBER_TARGET_BUCKET, val)?;
   93     93   
        }
   94     94   
        if let Some(ref val) = self.target_grants {
   95     95   
            ser.write_list(
   96     96   
                &LOGGINGENABLED_MEMBER_TARGET_GRANTS,
   97     97   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   98     98   
                    for item in val {
   99     99   
                        ser.write_struct(crate::types::TargetGrant::SCHEMA, item)?;
  100    100   
                    }
  101    101   
                    Ok(())
  102    102   
                },
  103    103   
            )?;
  104    104   
        }
  105    105   
        {
  106    106   
            let val = &self.target_prefix;
  107    107   
            ser.write_string(&LOGGINGENABLED_MEMBER_TARGET_PREFIX, val)?;
  108    108   
        }
  109    109   
        if let Some(ref val) = self.target_object_key_format {
  110    110   
            ser.write_struct(&LOGGINGENABLED_MEMBER_TARGET_OBJECT_KEY_FORMAT, val)?;
  111    111   
        }
  112    112   
        Ok(())
  113    113   
    }
  114    114   
}
  115    115   
impl LoggingEnabled {
  116    116   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  117         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  118         -
        deserializer: &mut D,
         117  +
    pub fn deserialize(
         118  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  119    119   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  120    120   
        #[allow(unused_variables, unused_mut)]
  121    121   
        let mut builder = Self::builder();
  122    122   
        #[allow(
  123    123   
            unused_variables,
  124    124   
            unreachable_code,
  125    125   
            clippy::single_match,
  126    126   
            clippy::match_single_binding,
  127    127   
            clippy::diverging_sub_expression
  128    128   
        )]
  129         -
        deserializer.read_struct(&LOGGINGENABLED_SCHEMA, (), |_, member, deser| {
         129  +
        deserializer.read_struct(&LOGGINGENABLED_SCHEMA, &mut |member, deser| {
  130    130   
            match member.member_index() {
  131    131   
                Some(0) => {
  132    132   
                    builder.target_bucket = Some(deser.read_string(member)?);
  133    133   
                }
  134    134   
                Some(1) => {
  135    135   
                    builder.target_grants = Some({
  136         -
                        let container = if let Some(cap) = deser.container_size() {
  137         -
                            Vec::with_capacity(cap)
  138         -
                        } else {
  139         -
                            Vec::new()
  140         -
                        };
  141         -
                        deser.read_list(member, container, |mut list, deser| {
  142         -
                            list.push(crate::types::TargetGrant::deserialize(deser)?);
  143         -
                            Ok(list)
  144         -
                        })?
         136  +
                        let mut container = Vec::new();
         137  +
                        deser.read_list(member, &mut |deser| {
         138  +
                            container.push(crate::types::TargetGrant::deserialize(deser)?);
         139  +
                            Ok(())
         140  +
                        })?;
         141  +
                        container
  145    142   
                    });
  146    143   
                }
  147    144   
                Some(2) => {
  148    145   
                    builder.target_prefix = Some(deser.read_string(member)?);
  149    146   
                }
  150    147   
                Some(3) => {
  151    148   
                    builder.target_object_key_format = Some(crate::types::TargetObjectKeyFormat::deserialize(deser)?);
  152    149   
                }
  153    150   
                _ => {}
  154    151   
            }
  155    152   
            Ok(())
  156    153   
        })?;
         154  +
        builder.target_bucket = builder.target_bucket.or(Some(String::new()));
         155  +
        builder.target_prefix = builder.target_prefix.or(Some(String::new()));
  157    156   
        builder
  158    157   
            .build()
  159    158   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  160    159   
    }
  161    160   
}
         161  +
impl LoggingEnabled {
         162  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         163  +
    pub fn deserialize_with_response(
         164  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         165  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         166  +
        _status: u16,
         167  +
        _body: &[u8],
         168  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         169  +
        Self::deserialize(deserializer)
         170  +
    }
         171  +
}
  162    172   
impl LoggingEnabled {
  163    173   
    /// Creates a new builder-style object to manufacture [`LoggingEnabled`](crate::types::LoggingEnabled).
  164    174   
    pub fn builder() -> crate::types::builders::LoggingEnabledBuilder {
  165    175   
        crate::types::builders::LoggingEnabledBuilder::default()
  166    176   
    }
  167    177   
}
  168    178   
  169    179   
/// A builder for [`LoggingEnabled`](crate::types::LoggingEnabled).
  170    180   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  171    181   
#[non_exhaustive]

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

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

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

@@ -10,10 +155,166 @@
   30     30   
    "com.amazonaws.s3",
   31     31   
    "MetadataConfigurationResult",
   32     32   
);
   33     33   
static METADATACONFIGURATIONRESULT_MEMBER_DESTINATION_RESULT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.s3#MetadataConfigurationResult$DestinationResult",
   36     36   
        "com.amazonaws.s3",
   37     37   
        "MetadataConfigurationResult",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Structure,
   40         -
    "destination_result",
          40  +
    "DestinationResult",
   41     41   
    0,
   42     42   
);
   43     43   
static METADATACONFIGURATIONRESULT_MEMBER_JOURNAL_TABLE_CONFIGURATION_RESULT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.s3#MetadataConfigurationResult$JournalTableConfigurationResult",
   46     46   
        "com.amazonaws.s3",
   47     47   
        "MetadataConfigurationResult",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50         -
    "journal_table_configuration_result",
          50  +
    "JournalTableConfigurationResult",
   51     51   
    1,
   52     52   
);
   53     53   
static METADATACONFIGURATIONRESULT_MEMBER_INVENTORY_TABLE_CONFIGURATION_RESULT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.s3#MetadataConfigurationResult$InventoryTableConfigurationResult",
   56     56   
        "com.amazonaws.s3",
   57     57   
        "MetadataConfigurationResult",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Structure,
   60         -
    "inventory_table_configuration_result",
          60  +
    "InventoryTableConfigurationResult",
   61     61   
    2,
   62     62   
);
   63     63   
static METADATACONFIGURATIONRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    METADATACONFIGURATIONRESULT_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &METADATACONFIGURATIONRESULT_MEMBER_DESTINATION_RESULT,
   68     68   
        &METADATACONFIGURATIONRESULT_MEMBER_JOURNAL_TABLE_CONFIGURATION_RESULT,
   69     69   
        &METADATACONFIGURATIONRESULT_MEMBER_INVENTORY_TABLE_CONFIGURATION_RESULT,
   70     70   
    ],
   71     71   
);
   72     72   
impl MetadataConfigurationResult {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &METADATACONFIGURATIONRESULT_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for MetadataConfigurationResult {
   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.destination_result {
   83     83   
            ser.write_struct(&METADATACONFIGURATIONRESULT_MEMBER_DESTINATION_RESULT, val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.journal_table_configuration_result {
   86     86   
            ser.write_struct(&METADATACONFIGURATIONRESULT_MEMBER_JOURNAL_TABLE_CONFIGURATION_RESULT, val)?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.inventory_table_configuration_result {
   89     89   
            ser.write_struct(&METADATACONFIGURATIONRESULT_MEMBER_INVENTORY_TABLE_CONFIGURATION_RESULT, val)?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl MetadataConfigurationResult {
   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(&METADATACONFIGURATIONRESULT_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&METADATACONFIGURATIONRESULT_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.destination_result = Some(crate::types::DestinationResult::deserialize(deser)?);
  112    112   
                }
  113    113   
                Some(1) => {
  114    114   
                    builder.journal_table_configuration_result = Some(crate::types::JournalTableConfigurationResult::deserialize(deser)?);
  115    115   
                }
  116    116   
                Some(2) => {
  117    117   
                    builder.inventory_table_configuration_result = Some(crate::types::InventoryTableConfigurationResult::deserialize(deser)?);
  118    118   
                }
  119    119   
                _ => {}
  120    120   
            }
  121    121   
            Ok(())
  122    122   
        })?;
  123    123   
        Ok(builder.build())
  124    124   
    }
  125    125   
}
         126  +
impl MetadataConfigurationResult {
         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 MetadataConfigurationResult {
  127    138   
    /// Creates a new builder-style object to manufacture [`MetadataConfigurationResult`](crate::types::MetadataConfigurationResult).
  128    139   
    pub fn builder() -> crate::types::builders::MetadataConfigurationResultBuilder {
  129    140   
        crate::types::builders::MetadataConfigurationResultBuilder::default()
  130    141   
    }
  131    142   
}
  132    143   
  133    144   
/// A builder for [`MetadataConfigurationResult`](crate::types::MetadataConfigurationResult).
  134    145   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  135    146   
#[non_exhaustive]