AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406 (ignoring whitespace)

Files changed:

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

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

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

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

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

@@ -34,34 +150,150 @@
   54     54   
}
   55     55   
static INVENTORYCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   56     56   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InventoryConfiguration", "com.amazonaws.s3", "InventoryConfiguration");
   57     57   
static INVENTORYCONFIGURATION_MEMBER_DESTINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.s3#InventoryConfiguration$Destination",
   60     60   
        "com.amazonaws.s3",
   61     61   
        "InventoryConfiguration",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::Structure,
   64         -
    "destination",
          64  +
    "Destination",
   65     65   
    0,
   66     66   
);
   67     67   
static INVENTORYCONFIGURATION_MEMBER_IS_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.s3#InventoryConfiguration$IsEnabled",
   70     70   
        "com.amazonaws.s3",
   71     71   
        "InventoryConfiguration",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::Boolean,
   74         -
    "is_enabled",
          74  +
    "IsEnabled",
   75     75   
    1,
   76     76   
);
   77     77   
static INVENTORYCONFIGURATION_MEMBER_FILTER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.s3#InventoryConfiguration$Filter",
   80     80   
        "com.amazonaws.s3",
   81     81   
        "InventoryConfiguration",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::Structure,
   84         -
    "filter",
          84  +
    "Filter",
   85     85   
    2,
   86     86   
);
   87     87   
static INVENTORYCONFIGURATION_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#InventoryConfiguration$Id", "com.amazonaws.s3", "InventoryConfiguration"),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "id",
          90  +
    "Id",
   91     91   
    3,
   92     92   
);
   93     93   
static INVENTORYCONFIGURATION_MEMBER_INCLUDED_OBJECT_VERSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.s3#InventoryConfiguration$IncludedObjectVersions",
   96     96   
        "com.amazonaws.s3",
   97     97   
        "InventoryConfiguration",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "included_object_versions",
         100  +
    "IncludedObjectVersions",
  101    101   
    4,
  102    102   
);
  103    103   
static INVENTORYCONFIGURATION_MEMBER_OPTIONAL_FIELDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.s3#InventoryConfiguration$OptionalFields",
  106    106   
        "com.amazonaws.s3",
  107    107   
        "InventoryConfiguration",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::List,
  110         -
    "optional_fields",
         110  +
    "OptionalFields",
  111    111   
    5,
  112    112   
);
  113    113   
static INVENTORYCONFIGURATION_MEMBER_SCHEDULE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static(
  115    115   
        "com.amazonaws.s3#InventoryConfiguration$Schedule",
  116    116   
        "com.amazonaws.s3",
  117    117   
        "InventoryConfiguration",
  118    118   
    ),
  119    119   
    ::aws_smithy_schema::ShapeType::Structure,
  120         -
    "schedule",
         120  +
    "Schedule",
  121    121   
    6,
  122    122   
);
  123    123   
static INVENTORYCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  124    124   
    INVENTORYCONFIGURATION_SCHEMA_ID,
  125    125   
    ::aws_smithy_schema::ShapeType::Structure,
  126    126   
    &[
  127    127   
        &INVENTORYCONFIGURATION_MEMBER_DESTINATION,
  128    128   
        &INVENTORYCONFIGURATION_MEMBER_IS_ENABLED,
  129    129   
        &INVENTORYCONFIGURATION_MEMBER_FILTER,
  130    130   
        &INVENTORYCONFIGURATION_MEMBER_ID,
@@ -153,153 +266,276 @@
  173    173   
            )?;
  174    174   
        }
  175    175   
        if let Some(ref val) = self.schedule {
  176    176   
            ser.write_struct(&INVENTORYCONFIGURATION_MEMBER_SCHEDULE, val)?;
  177    177   
        }
  178    178   
        Ok(())
  179    179   
    }
  180    180   
}
  181    181   
impl InventoryConfiguration {
  182    182   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  183         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  184         -
        deserializer: &mut D,
         183  +
    pub fn deserialize(
         184  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  185    185   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  186    186   
        #[allow(unused_variables, unused_mut)]
  187    187   
        let mut builder = Self::builder();
  188    188   
        #[allow(
  189    189   
            unused_variables,
  190    190   
            unreachable_code,
  191    191   
            clippy::single_match,
  192    192   
            clippy::match_single_binding,
  193    193   
            clippy::diverging_sub_expression
  194    194   
        )]
  195         -
        deserializer.read_struct(&INVENTORYCONFIGURATION_SCHEMA, (), |_, member, deser| {
         195  +
        deserializer.read_struct(&INVENTORYCONFIGURATION_SCHEMA, &mut |member, deser| {
  196    196   
            match member.member_index() {
  197    197   
                Some(0) => {
  198    198   
                    builder.destination = Some(crate::types::InventoryDestination::deserialize(deser)?);
  199    199   
                }
  200    200   
                Some(1) => {
  201    201   
                    builder.is_enabled = Some(deser.read_boolean(member)?);
  202    202   
                }
  203    203   
                Some(2) => {
  204    204   
                    builder.filter = Some(crate::types::InventoryFilter::deserialize(deser)?);
  205    205   
                }
  206    206   
                Some(3) => {
  207    207   
                    builder.id = Some(deser.read_string(member)?);
  208    208   
                }
  209    209   
                Some(4) => {
  210    210   
                    builder.included_object_versions = Some(crate::types::InventoryIncludedObjectVersions::from(deser.read_string(member)?.as_str()));
  211    211   
                }
  212    212   
                Some(5) => {
  213    213   
                    builder.optional_fields = Some({
  214         -
                        let container = if let Some(cap) = deser.container_size() {
  215         -
                            Vec::with_capacity(cap)
  216         -
                        } else {
  217         -
                            Vec::new()
  218         -
                        };
  219         -
                        deser.read_list(member, container, |mut list, deser| {
  220         -
                            list.push(crate::types::InventoryOptionalField::from(deser.read_string(member)?.as_str()));
  221         -
                            Ok(list)
  222         -
                        })?
         214  +
                        let mut container = Vec::new();
         215  +
                        deser.read_list(member, &mut |deser| {
         216  +
                            container.push(crate::types::InventoryOptionalField::from(deser.read_string(member)?.as_str()));
         217  +
                            Ok(())
         218  +
                        })?;
         219  +
                        container
  223    220   
                    });
  224    221   
                }
  225    222   
                Some(6) => {
  226    223   
                    builder.schedule = Some(crate::types::InventorySchedule::deserialize(deser)?);
  227    224   
                }
  228    225   
                _ => {}
  229    226   
            }
  230    227   
            Ok(())
  231    228   
        })?;
         229  +
        builder.is_enabled = builder.is_enabled.or(Some(false));
         230  +
        builder.id = builder.id.or(Some(String::new()));
  232    231   
        builder
  233    232   
            .build()
  234    233   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  235    234   
    }
  236    235   
}
         236  +
impl InventoryConfiguration {
         237  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         238  +
    pub fn deserialize_with_response(
         239  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         240  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         241  +
        _status: u16,
         242  +
        _body: &[u8],
         243  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         244  +
        Self::deserialize(deserializer)
         245  +
    }
         246  +
}
  237    247   
impl InventoryConfiguration {
  238    248   
    /// Creates a new builder-style object to manufacture [`InventoryConfiguration`](crate::types::InventoryConfiguration).
  239    249   
    pub fn builder() -> crate::types::builders::InventoryConfigurationBuilder {
  240    250   
        crate::types::builders::InventoryConfigurationBuilder::default()
  241    251   
    }
  242    252   
}
  243    253   
  244    254   
/// A builder for [`InventoryConfiguration`](crate::types::InventoryConfiguration).
  245    255   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  246    256   
#[non_exhaustive]

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

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

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

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

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

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

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

@@ -27,27 +210,222 @@
   47     47   
    "com.amazonaws.s3",
   48     48   
    "InventoryS3BucketDestination",
   49     49   
);
   50     50   
static INVENTORYS3BUCKETDESTINATION_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.s3#InventoryS3BucketDestination$AccountId",
   53     53   
        "com.amazonaws.s3",
   54     54   
        "InventoryS3BucketDestination",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "account_id",
          57  +
    "AccountId",
   58     58   
    0,
   59     59   
);
   60     60   
static INVENTORYS3BUCKETDESTINATION_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.s3#InventoryS3BucketDestination$Bucket",
   63     63   
        "com.amazonaws.s3",
   64     64   
        "InventoryS3BucketDestination",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::String,
   67         -
    "bucket",
          67  +
    "Bucket",
   68     68   
    1,
   69     69   
);
   70     70   
static INVENTORYS3BUCKETDESTINATION_MEMBER_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.s3#InventoryS3BucketDestination$Format",
   73     73   
        "com.amazonaws.s3",
   74     74   
        "InventoryS3BucketDestination",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "format",
          77  +
    "Format",
   78     78   
    2,
   79     79   
);
   80     80   
static INVENTORYS3BUCKETDESTINATION_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static(
   82     82   
        "com.amazonaws.s3#InventoryS3BucketDestination$Prefix",
   83     83   
        "com.amazonaws.s3",
   84     84   
        "InventoryS3BucketDestination",
   85     85   
    ),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "prefix",
          87  +
    "Prefix",
   88     88   
    3,
   89     89   
);
   90     90   
static INVENTORYS3BUCKETDESTINATION_MEMBER_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.s3#InventoryS3BucketDestination$Encryption",
   93     93   
        "com.amazonaws.s3",
   94     94   
        "InventoryS3BucketDestination",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::Structure,
   97         -
    "encryption",
          97  +
    "Encryption",
   98     98   
    4,
   99     99   
);
  100    100   
static INVENTORYS3BUCKETDESTINATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  101    101   
    INVENTORYS3BUCKETDESTINATION_SCHEMA_ID,
  102    102   
    ::aws_smithy_schema::ShapeType::Structure,
  103    103   
    &[
  104    104   
        &INVENTORYS3BUCKETDESTINATION_MEMBER_ACCOUNT_ID,
  105    105   
        &INVENTORYS3BUCKETDESTINATION_MEMBER_BUCKET,
  106    106   
        &INVENTORYS3BUCKETDESTINATION_MEMBER_FORMAT,
  107    107   
        &INVENTORYS3BUCKETDESTINATION_MEMBER_PREFIX,
  108    108   
        &INVENTORYS3BUCKETDESTINATION_MEMBER_ENCRYPTION,
  109    109   
    ],
  110    110   
);
  111    111   
impl InventoryS3BucketDestination {
  112    112   
    /// The schema for this shape.
  113    113   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVENTORYS3BUCKETDESTINATION_SCHEMA;
  114    114   
}
  115    115   
impl ::aws_smithy_schema::serde::SerializableStruct for InventoryS3BucketDestination {
  116    116   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  117    117   
    fn serialize_members(
  118    118   
        &self,
  119    119   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  120    120   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  121    121   
        if let Some(ref val) = self.account_id {
  122    122   
            ser.write_string(&INVENTORYS3BUCKETDESTINATION_MEMBER_ACCOUNT_ID, val)?;
  123    123   
        }
  124    124   
        {
  125    125   
            let val = &self.bucket;
  126    126   
            ser.write_string(&INVENTORYS3BUCKETDESTINATION_MEMBER_BUCKET, val)?;
  127    127   
        }
  128    128   
        {
  129    129   
            let val = &self.format;
  130    130   
            ser.write_string(&INVENTORYS3BUCKETDESTINATION_MEMBER_FORMAT, val.as_str())?;
  131    131   
        }
  132    132   
        if let Some(ref val) = self.prefix {
  133    133   
            ser.write_string(&INVENTORYS3BUCKETDESTINATION_MEMBER_PREFIX, val)?;
  134    134   
        }
  135    135   
        if let Some(ref val) = self.encryption {
  136    136   
            ser.write_struct(&INVENTORYS3BUCKETDESTINATION_MEMBER_ENCRYPTION, val)?;
  137    137   
        }
  138    138   
        Ok(())
  139    139   
    }
  140    140   
}
  141    141   
impl InventoryS3BucketDestination {
  142    142   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  143         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  144         -
        deserializer: &mut D,
         143  +
    pub fn deserialize(
         144  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  145    145   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  146    146   
        #[allow(unused_variables, unused_mut)]
  147    147   
        let mut builder = Self::builder();
  148    148   
        #[allow(
  149    149   
            unused_variables,
  150    150   
            unreachable_code,
  151    151   
            clippy::single_match,
  152    152   
            clippy::match_single_binding,
  153    153   
            clippy::diverging_sub_expression
  154    154   
        )]
  155         -
        deserializer.read_struct(&INVENTORYS3BUCKETDESTINATION_SCHEMA, (), |_, member, deser| {
         155  +
        deserializer.read_struct(&INVENTORYS3BUCKETDESTINATION_SCHEMA, &mut |member, deser| {
  156    156   
            match member.member_index() {
  157    157   
                Some(0) => {
  158    158   
                    builder.account_id = Some(deser.read_string(member)?);
  159    159   
                }
  160    160   
                Some(1) => {
  161    161   
                    builder.bucket = Some(deser.read_string(member)?);
  162    162   
                }
  163    163   
                Some(2) => {
  164    164   
                    builder.format = Some(crate::types::InventoryFormat::from(deser.read_string(member)?.as_str()));
  165    165   
                }
  166    166   
                Some(3) => {
  167    167   
                    builder.prefix = Some(deser.read_string(member)?);
  168    168   
                }
  169    169   
                Some(4) => {
  170    170   
                    builder.encryption = Some(crate::types::InventoryEncryption::deserialize(deser)?);
  171    171   
                }
  172    172   
                _ => {}
  173    173   
            }
  174    174   
            Ok(())
  175    175   
        })?;
         176  +
        builder.bucket = builder.bucket.or(Some(String::new()));
  176    177   
        builder
  177    178   
            .build()
  178    179   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  179    180   
    }
  180    181   
}
         182  +
impl InventoryS3BucketDestination {
         183  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         184  +
    pub fn deserialize_with_response(
         185  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         186  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         187  +
        _status: u16,
         188  +
        _body: &[u8],
         189  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         190  +
        Self::deserialize(deserializer)
         191  +
    }
         192  +
}
  181    193   
impl InventoryS3BucketDestination {
  182    194   
    /// Creates a new builder-style object to manufacture [`InventoryS3BucketDestination`](crate::types::InventoryS3BucketDestination).
  183    195   
    pub fn builder() -> crate::types::builders::InventoryS3BucketDestinationBuilder {
  184    196   
        crate::types::builders::InventoryS3BucketDestinationBuilder::default()
  185    197   
    }
  186    198   
}
  187    199   
  188    200   
/// A builder for [`InventoryS3BucketDestination`](crate::types::InventoryS3BucketDestination).
  189    201   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  190    202   
#[non_exhaustive]

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

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

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

@@ -4,4 +135,146 @@
   24     24   
    "com.amazonaws.s3",
   25     25   
    "InventoryTableConfiguration",
   26     26   
);
   27     27   
static INVENTORYTABLECONFIGURATION_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#InventoryTableConfiguration$ConfigurationState",
   30     30   
        "com.amazonaws.s3",
   31     31   
        "InventoryTableConfiguration",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "configuration_state",
          34  +
    "ConfigurationState",
   35     35   
    0,
   36     36   
);
   37     37   
static INVENTORYTABLECONFIGURATION_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#InventoryTableConfiguration$EncryptionConfiguration",
   40     40   
        "com.amazonaws.s3",
   41     41   
        "InventoryTableConfiguration",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Structure,
   44         -
    "encryption_configuration",
          44  +
    "EncryptionConfiguration",
   45     45   
    1,
   46     46   
);
   47     47   
static INVENTORYTABLECONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    INVENTORYTABLECONFIGURATION_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[
   51     51   
        &INVENTORYTABLECONFIGURATION_MEMBER_CONFIGURATION_STATE,
   52     52   
        &INVENTORYTABLECONFIGURATION_MEMBER_ENCRYPTION_CONFIGURATION,
   53     53   
    ],
   54     54   
);
   55     55   
impl InventoryTableConfiguration {
   56     56   
    /// The schema for this shape.
   57     57   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVENTORYTABLECONFIGURATION_SCHEMA;
   58     58   
}
   59     59   
impl ::aws_smithy_schema::serde::SerializableStruct for InventoryTableConfiguration {
   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(&INVENTORYTABLECONFIGURATION_MEMBER_CONFIGURATION_STATE, val.as_str())?;
   68     68   
        }
   69     69   
        if let Some(ref val) = self.encryption_configuration {
   70     70   
            ser.write_struct(&INVENTORYTABLECONFIGURATION_MEMBER_ENCRYPTION_CONFIGURATION, val)?;
   71     71   
        }
   72     72   
        Ok(())
   73     73   
    }
   74     74   
}
   75     75   
impl InventoryTableConfiguration {
   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(&INVENTORYTABLECONFIGURATION_SCHEMA, (), |_, member, deser| {
          89  +
        deserializer.read_struct(&INVENTORYTABLECONFIGURATION_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 InventoryTableConfiguration {
         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 InventoryTableConfiguration {
  107    118   
    /// Creates a new builder-style object to manufacture [`InventoryTableConfiguration`](crate::types::InventoryTableConfiguration).
  108    119   
    pub fn builder() -> crate::types::builders::InventoryTableConfigurationBuilder {
  109    120   
        crate::types::builders::InventoryTableConfigurationBuilder::default()
  110    121   
    }
  111    122   
}
  112    123   
  113    124   
/// A builder for [`InventoryTableConfiguration`](crate::types::InventoryTableConfiguration).
  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/_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]