AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_point_in_time_recovery_specification.rs

@@ -4,4 +135,147 @@
   24     24   
    "com.amazonaws.dynamodb",
   25     25   
    "PointInTimeRecoverySpecification",
   26     26   
);
   27     27   
static POINTINTIMERECOVERYSPECIFICATION_MEMBER_POINT_IN_TIME_RECOVERY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.dynamodb#PointInTimeRecoverySpecification$PointInTimeRecoveryEnabled",
   30     30   
        "com.amazonaws.dynamodb",
   31     31   
        "PointInTimeRecoverySpecification",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::Boolean,
   34         -
    "point_in_time_recovery_enabled",
          34  +
    "PointInTimeRecoveryEnabled",
   35     35   
    0,
   36     36   
);
   37     37   
static POINTINTIMERECOVERYSPECIFICATION_MEMBER_RECOVERY_PERIOD_IN_DAYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.dynamodb#PointInTimeRecoverySpecification$RecoveryPeriodInDays",
   40     40   
        "com.amazonaws.dynamodb",
   41     41   
        "PointInTimeRecoverySpecification",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Integer,
   44         -
    "recovery_period_in_days",
          44  +
    "RecoveryPeriodInDays",
   45     45   
    1,
   46     46   
);
   47     47   
static POINTINTIMERECOVERYSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    POINTINTIMERECOVERYSPECIFICATION_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[
   51     51   
        &POINTINTIMERECOVERYSPECIFICATION_MEMBER_POINT_IN_TIME_RECOVERY_ENABLED,
   52     52   
        &POINTINTIMERECOVERYSPECIFICATION_MEMBER_RECOVERY_PERIOD_IN_DAYS,
   53     53   
    ],
   54     54   
);
   55     55   
impl PointInTimeRecoverySpecification {
   56     56   
    /// The schema for this shape.
   57     57   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &POINTINTIMERECOVERYSPECIFICATION_SCHEMA;
   58     58   
}
   59     59   
impl ::aws_smithy_schema::serde::SerializableStruct for PointInTimeRecoverySpecification {
   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.point_in_time_recovery_enabled;
   67     67   
            ser.write_boolean(&POINTINTIMERECOVERYSPECIFICATION_MEMBER_POINT_IN_TIME_RECOVERY_ENABLED, *val)?;
   68     68   
        }
   69     69   
        if let Some(ref val) = self.recovery_period_in_days {
   70     70   
            ser.write_integer(&POINTINTIMERECOVERYSPECIFICATION_MEMBER_RECOVERY_PERIOD_IN_DAYS, *val)?;
   71     71   
        }
   72     72   
        Ok(())
   73     73   
    }
   74     74   
}
   75     75   
impl PointInTimeRecoverySpecification {
   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(&POINTINTIMERECOVERYSPECIFICATION_SCHEMA, (), |_, member, deser| {
          89  +
        deserializer.read_struct(&POINTINTIMERECOVERYSPECIFICATION_SCHEMA, &mut |member, deser| {
   90     90   
            match member.member_index() {
   91     91   
                Some(0) => {
   92     92   
                    builder.point_in_time_recovery_enabled = Some(deser.read_boolean(member)?);
   93     93   
                }
   94     94   
                Some(1) => {
   95     95   
                    builder.recovery_period_in_days = Some(deser.read_integer(member)?);
   96     96   
                }
   97     97   
                _ => {}
   98     98   
            }
   99     99   
            Ok(())
  100    100   
        })?;
         101  +
        builder.point_in_time_recovery_enabled = builder.point_in_time_recovery_enabled.or(Some(false));
  101    102   
        builder
  102    103   
            .build()
  103    104   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  104    105   
    }
  105    106   
}
         107  +
impl PointInTimeRecoverySpecification {
         108  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         109  +
    pub fn deserialize_with_response(
         110  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         111  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         112  +
        _status: u16,
         113  +
        _body: &[u8],
         114  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         115  +
        Self::deserialize(deserializer)
         116  +
    }
         117  +
}
  106    118   
impl PointInTimeRecoverySpecification {
  107    119   
    /// Creates a new builder-style object to manufacture [`PointInTimeRecoverySpecification`](crate::types::PointInTimeRecoverySpecification).
  108    120   
    pub fn builder() -> crate::types::builders::PointInTimeRecoverySpecificationBuilder {
  109    121   
        crate::types::builders::PointInTimeRecoverySpecificationBuilder::default()
  110    122   
    }
  111    123   
}
  112    124   
  113    125   
/// A builder for [`PointInTimeRecoverySpecification`](crate::types::PointInTimeRecoverySpecification).
  114    126   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  115    127   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_projection.rs

@@ -19,19 +162,163 @@
   39     39   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.non_key_attributes.is_none()`.
   40     40   
    pub fn non_key_attributes(&self) -> &[::std::string::String] {
   41     41   
        self.non_key_attributes.as_deref().unwrap_or_default()
   42     42   
    }
   43     43   
}
   44     44   
static PROJECTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   45     45   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Projection", "com.amazonaws.dynamodb", "Projection");
   46     46   
static PROJECTION_MEMBER_PROJECTION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Projection$ProjectionType", "com.amazonaws.dynamodb", "Projection"),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "projection_type",
          49  +
    "ProjectionType",
   50     50   
    0,
   51     51   
);
   52     52   
static PROJECTION_MEMBER_NON_KEY_ATTRIBUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.dynamodb#Projection$NonKeyAttributes",
   55     55   
        "com.amazonaws.dynamodb",
   56     56   
        "Projection",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::List,
   59         -
    "non_key_attributes",
          59  +
    "NonKeyAttributes",
   60     60   
    1,
   61     61   
);
   62     62   
static PROJECTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   63     63   
    PROJECTION_SCHEMA_ID,
   64     64   
    ::aws_smithy_schema::ShapeType::Structure,
   65     65   
    &[&PROJECTION_MEMBER_PROJECTION_TYPE, &PROJECTION_MEMBER_NON_KEY_ATTRIBUTES],
   66     66   
);
   67     67   
impl Projection {
   68     68   
    /// The schema for this shape.
   69     69   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PROJECTION_SCHEMA;
   70     70   
}
   71     71   
impl ::aws_smithy_schema::serde::SerializableStruct for Projection {
   72     72   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   73     73   
    fn serialize_members(
   74     74   
        &self,
   75     75   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   76     76   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   77     77   
        if let Some(ref val) = self.projection_type {
   78     78   
            ser.write_string(&PROJECTION_MEMBER_PROJECTION_TYPE, val.as_str())?;
   79     79   
        }
   80     80   
        if let Some(ref val) = self.non_key_attributes {
   81     81   
            ser.write_list(
   82     82   
                &PROJECTION_MEMBER_NON_KEY_ATTRIBUTES,
   83     83   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   84     84   
                    for item in val {
   85     85   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
   86     86   
                    }
   87     87   
                    Ok(())
   88     88   
                },
   89     89   
            )?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl Projection {
   95     95   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   96         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   97         -
        deserializer: &mut D,
          96  +
    pub fn deserialize(
          97  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   98     98   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   99     99   
        #[allow(unused_variables, unused_mut)]
  100    100   
        let mut builder = Self::builder();
  101    101   
        #[allow(
  102    102   
            unused_variables,
  103    103   
            unreachable_code,
  104    104   
            clippy::single_match,
  105    105   
            clippy::match_single_binding,
  106    106   
            clippy::diverging_sub_expression
  107    107   
        )]
  108         -
        deserializer.read_struct(&PROJECTION_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&PROJECTION_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.projection_type = Some(crate::types::ProjectionType::from(deser.read_string(member)?.as_str()));
  112    112   
                }
  113    113   
                Some(1) => {
  114         -
                    builder.non_key_attributes = Some({
  115         -
                        let container = if let Some(cap) = deser.container_size() {
  116         -
                            Vec::with_capacity(cap)
  117         -
                        } else {
  118         -
                            Vec::new()
  119         -
                        };
  120         -
                        deser.read_list(member, container, |mut list, deser| {
  121         -
                            list.push(deser.read_string(member)?);
  122         -
                            Ok(list)
  123         -
                        })?
  124         -
                    });
         114  +
                    builder.non_key_attributes = Some(deser.read_string_list(member)?);
  125    115   
                }
  126    116   
                _ => {}
  127    117   
            }
  128    118   
            Ok(())
  129    119   
        })?;
  130    120   
        Ok(builder.build())
  131    121   
    }
  132    122   
}
         123  +
impl Projection {
         124  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         125  +
    pub fn deserialize_with_response(
         126  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         127  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         128  +
        _status: u16,
         129  +
        _body: &[u8],
         130  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         131  +
        Self::deserialize(deserializer)
         132  +
    }
         133  +
}
  133    134   
impl Projection {
  134    135   
    /// Creates a new builder-style object to manufacture [`Projection`](crate::types::Projection).
  135    136   
    pub fn builder() -> crate::types::builders::ProjectionBuilder {
  136    137   
        crate::types::builders::ProjectionBuilder::default()
  137    138   
    }
  138    139   
}
  139    140   
  140    141   
/// A builder for [`Projection`](crate::types::Projection).
  141    142   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  142    143   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_provisioned_throughput.rs

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_provisioned_throughput_description.rs

@@ -22,22 +201,212 @@
   42     42   
    "com.amazonaws.dynamodb",
   43     43   
    "ProvisionedThroughputDescription",
   44     44   
);
   45     45   
static PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_LAST_INCREASE_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static(
   47     47   
        "com.amazonaws.dynamodb#ProvisionedThroughputDescription$LastIncreaseDateTime",
   48     48   
        "com.amazonaws.dynamodb",
   49     49   
        "ProvisionedThroughputDescription",
   50     50   
    ),
   51     51   
    ::aws_smithy_schema::ShapeType::Timestamp,
   52         -
    "last_increase_date_time",
          52  +
    "LastIncreaseDateTime",
   53     53   
    0,
   54     54   
);
   55     55   
static PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_LAST_DECREASE_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.dynamodb#ProvisionedThroughputDescription$LastDecreaseDateTime",
   58     58   
        "com.amazonaws.dynamodb",
   59     59   
        "ProvisionedThroughputDescription",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::Timestamp,
   62         -
    "last_decrease_date_time",
          62  +
    "LastDecreaseDateTime",
   63     63   
    1,
   64     64   
);
   65     65   
static PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_NUMBER_OF_DECREASES_TODAY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static(
   67     67   
        "com.amazonaws.dynamodb#ProvisionedThroughputDescription$NumberOfDecreasesToday",
   68     68   
        "com.amazonaws.dynamodb",
   69     69   
        "ProvisionedThroughputDescription",
   70     70   
    ),
   71     71   
    ::aws_smithy_schema::ShapeType::Long,
   72         -
    "number_of_decreases_today",
          72  +
    "NumberOfDecreasesToday",
   73     73   
    2,
   74     74   
);
   75     75   
static PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_READ_CAPACITY_UNITS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static(
   77     77   
        "com.amazonaws.dynamodb#ProvisionedThroughputDescription$ReadCapacityUnits",
   78     78   
        "com.amazonaws.dynamodb",
   79     79   
        "ProvisionedThroughputDescription",
   80     80   
    ),
   81     81   
    ::aws_smithy_schema::ShapeType::Long,
   82         -
    "read_capacity_units",
          82  +
    "ReadCapacityUnits",
   83     83   
    3,
   84     84   
);
   85     85   
static PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_WRITE_CAPACITY_UNITS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "com.amazonaws.dynamodb#ProvisionedThroughputDescription$WriteCapacityUnits",
   88     88   
        "com.amazonaws.dynamodb",
   89     89   
        "ProvisionedThroughputDescription",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::Long,
   92         -
    "write_capacity_units",
          92  +
    "WriteCapacityUnits",
   93     93   
    4,
   94     94   
);
   95     95   
static PROVISIONEDTHROUGHPUTDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   96     96   
    PROVISIONEDTHROUGHPUTDESCRIPTION_SCHEMA_ID,
   97     97   
    ::aws_smithy_schema::ShapeType::Structure,
   98     98   
    &[
   99     99   
        &PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_LAST_INCREASE_DATE_TIME,
  100    100   
        &PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_LAST_DECREASE_DATE_TIME,
  101    101   
        &PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_NUMBER_OF_DECREASES_TODAY,
  102    102   
        &PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_READ_CAPACITY_UNITS,
  103    103   
        &PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_WRITE_CAPACITY_UNITS,
  104    104   
    ],
  105    105   
);
  106    106   
impl ProvisionedThroughputDescription {
  107    107   
    /// The schema for this shape.
  108    108   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PROVISIONEDTHROUGHPUTDESCRIPTION_SCHEMA;
  109    109   
}
  110    110   
impl ::aws_smithy_schema::serde::SerializableStruct for ProvisionedThroughputDescription {
  111    111   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  112    112   
    fn serialize_members(
  113    113   
        &self,
  114    114   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  115    115   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  116    116   
        if let Some(ref val) = self.last_increase_date_time {
  117    117   
            ser.write_timestamp(&PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_LAST_INCREASE_DATE_TIME, val)?;
  118    118   
        }
  119    119   
        if let Some(ref val) = self.last_decrease_date_time {
  120    120   
            ser.write_timestamp(&PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_LAST_DECREASE_DATE_TIME, val)?;
  121    121   
        }
  122    122   
        if let Some(ref val) = self.number_of_decreases_today {
  123    123   
            ser.write_long(&PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_NUMBER_OF_DECREASES_TODAY, *val)?;
  124    124   
        }
  125    125   
        if let Some(ref val) = self.read_capacity_units {
  126    126   
            ser.write_long(&PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_READ_CAPACITY_UNITS, *val)?;
  127    127   
        }
  128    128   
        if let Some(ref val) = self.write_capacity_units {
  129    129   
            ser.write_long(&PROVISIONEDTHROUGHPUTDESCRIPTION_MEMBER_WRITE_CAPACITY_UNITS, *val)?;
  130    130   
        }
  131    131   
        Ok(())
  132    132   
    }
  133    133   
}
  134    134   
impl ProvisionedThroughputDescription {
  135    135   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  136         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  137         -
        deserializer: &mut D,
         136  +
    pub fn deserialize(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  138    138   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  139    139   
        #[allow(unused_variables, unused_mut)]
  140    140   
        let mut builder = Self::builder();
  141    141   
        #[allow(
  142    142   
            unused_variables,
  143    143   
            unreachable_code,
  144    144   
            clippy::single_match,
  145    145   
            clippy::match_single_binding,
  146    146   
            clippy::diverging_sub_expression
  147    147   
        )]
  148         -
        deserializer.read_struct(&PROVISIONEDTHROUGHPUTDESCRIPTION_SCHEMA, (), |_, member, deser| {
         148  +
        deserializer.read_struct(&PROVISIONEDTHROUGHPUTDESCRIPTION_SCHEMA, &mut |member, deser| {
  149    149   
            match member.member_index() {
  150    150   
                Some(0) => {
  151    151   
                    builder.last_increase_date_time = Some(deser.read_timestamp(member)?);
  152    152   
                }
  153    153   
                Some(1) => {
  154    154   
                    builder.last_decrease_date_time = Some(deser.read_timestamp(member)?);
  155    155   
                }
  156    156   
                Some(2) => {
  157    157   
                    builder.number_of_decreases_today = Some(deser.read_long(member)?);
  158    158   
                }
  159    159   
                Some(3) => {
  160    160   
                    builder.read_capacity_units = Some(deser.read_long(member)?);
  161    161   
                }
  162    162   
                Some(4) => {
  163    163   
                    builder.write_capacity_units = Some(deser.read_long(member)?);
  164    164   
                }
  165    165   
                _ => {}
  166    166   
            }
  167    167   
            Ok(())
  168    168   
        })?;
  169    169   
        Ok(builder.build())
  170    170   
    }
  171    171   
}
         172  +
impl ProvisionedThroughputDescription {
         173  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         174  +
    pub fn deserialize_with_response(
         175  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         176  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         177  +
        _status: u16,
         178  +
        _body: &[u8],
         179  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         180  +
        Self::deserialize(deserializer)
         181  +
    }
         182  +
}
  172    183   
impl ProvisionedThroughputDescription {
  173    184   
    /// Creates a new builder-style object to manufacture [`ProvisionedThroughputDescription`](crate::types::ProvisionedThroughputDescription).
  174    185   
    pub fn builder() -> crate::types::builders::ProvisionedThroughputDescriptionBuilder {
  175    186   
        crate::types::builders::ProvisionedThroughputDescriptionBuilder::default()
  176    187   
    }
  177    188   
}
  178    189   
  179    190   
/// A builder for [`ProvisionedThroughputDescription`](crate::types::ProvisionedThroughputDescription).
  180    191   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  181    192   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_provisioned_throughput_override.rs

@@ -1,1 +107,118 @@
   18     18   
    "com.amazonaws.dynamodb",
   19     19   
    "ProvisionedThroughputOverride",
   20     20   
);
   21     21   
static PROVISIONEDTHROUGHPUTOVERRIDE_MEMBER_READ_CAPACITY_UNITS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.dynamodb#ProvisionedThroughputOverride$ReadCapacityUnits",
   24     24   
        "com.amazonaws.dynamodb",
   25     25   
        "ProvisionedThroughputOverride",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Long,
   28         -
    "read_capacity_units",
          28  +
    "ReadCapacityUnits",
   29     29   
    0,
   30     30   
);
   31     31   
static PROVISIONEDTHROUGHPUTOVERRIDE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    PROVISIONEDTHROUGHPUTOVERRIDE_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&PROVISIONEDTHROUGHPUTOVERRIDE_MEMBER_READ_CAPACITY_UNITS],
   35     35   
);
   36     36   
impl ProvisionedThroughputOverride {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PROVISIONEDTHROUGHPUTOVERRIDE_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for ProvisionedThroughputOverride {
   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.read_capacity_units {
   47     47   
            ser.write_long(&PROVISIONEDTHROUGHPUTOVERRIDE_MEMBER_READ_CAPACITY_UNITS, *val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl ProvisionedThroughputOverride {
   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(&PROVISIONEDTHROUGHPUTOVERRIDE_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&PROVISIONEDTHROUGHPUTOVERRIDE_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.read_capacity_units = Some(deser.read_long(member)?);
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl ProvisionedThroughputOverride {
          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 ProvisionedThroughputOverride {
   79     90   
    /// Creates a new builder-style object to manufacture [`ProvisionedThroughputOverride`](crate::types::ProvisionedThroughputOverride).
   80     91   
    pub fn builder() -> crate::types::builders::ProvisionedThroughputOverrideBuilder {
   81     92   
        crate::types::builders::ProvisionedThroughputOverrideBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`ProvisionedThroughputOverride`](crate::types::ProvisionedThroughputOverride).
   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/dynamodb/src/types/_put.rs

@@ -24,24 +265,262 @@
   44     44   
    /// <p>Use <code>ReturnValuesOnConditionCheckFailure</code> to get the item attributes if the <code>Put</code> condition fails. For <code>ReturnValuesOnConditionCheckFailure</code>, the valid values are: NONE and ALL_OLD.</p>
   45     45   
    pub fn return_values_on_condition_check_failure(&self) -> ::std::option::Option<&crate::types::ReturnValuesOnConditionCheckFailure> {
   46     46   
        self.return_values_on_condition_check_failure.as_ref()
   47     47   
    }
   48     48   
}
   49     49   
static PUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   50     50   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Put", "com.amazonaws.dynamodb", "Put");
   51     51   
static PUT_MEMBER_ITEM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Put$Item", "com.amazonaws.dynamodb", "Put"),
   53     53   
    ::aws_smithy_schema::ShapeType::Map,
   54         -
    "item",
          54  +
    "Item",
   55     55   
    0,
   56     56   
);
   57     57   
static PUT_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Put$TableName", "com.amazonaws.dynamodb", "Put"),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "table_name",
          60  +
    "TableName",
   61     61   
    1,
   62     62   
);
   63     63   
static PUT_MEMBER_CONDITION_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Put$ConditionExpression", "com.amazonaws.dynamodb", "Put"),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "condition_expression",
          66  +
    "ConditionExpression",
   67     67   
    2,
   68     68   
);
   69     69   
static PUT_MEMBER_EXPRESSION_ATTRIBUTE_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Put$ExpressionAttributeNames", "com.amazonaws.dynamodb", "Put"),
   71     71   
    ::aws_smithy_schema::ShapeType::Map,
   72         -
    "expression_attribute_names",
          72  +
    "ExpressionAttributeNames",
   73     73   
    3,
   74     74   
);
   75     75   
static PUT_MEMBER_EXPRESSION_ATTRIBUTE_VALUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Put$ExpressionAttributeValues", "com.amazonaws.dynamodb", "Put"),
   77     77   
    ::aws_smithy_schema::ShapeType::Map,
   78         -
    "expression_attribute_values",
          78  +
    "ExpressionAttributeValues",
   79     79   
    4,
   80     80   
);
   81     81   
static PUT_MEMBER_RETURN_VALUES_ON_CONDITION_CHECK_FAILURE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.dynamodb#Put$ReturnValuesOnConditionCheckFailure",
   84     84   
        "com.amazonaws.dynamodb",
   85     85   
        "Put",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::String,
   88         -
    "return_values_on_condition_check_failure",
          88  +
    "ReturnValuesOnConditionCheckFailure",
   89     89   
    5,
   90     90   
);
   91     91   
static PUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   92     92   
    PUT_SCHEMA_ID,
   93     93   
    ::aws_smithy_schema::ShapeType::Structure,
   94     94   
    &[
   95     95   
        &PUT_MEMBER_ITEM,
   96     96   
        &PUT_MEMBER_TABLE_NAME,
   97     97   
        &PUT_MEMBER_CONDITION_EXPRESSION,
   98     98   
        &PUT_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
   99     99   
        &PUT_MEMBER_EXPRESSION_ATTRIBUTE_VALUES,
  100    100   
        &PUT_MEMBER_RETURN_VALUES_ON_CONDITION_CHECK_FAILURE,
  101    101   
    ],
  102    102   
);
  103    103   
impl Put {
  104    104   
    /// The schema for this shape.
  105    105   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUT_SCHEMA;
  106    106   
}
  107    107   
impl ::aws_smithy_schema::serde::SerializableStruct for Put {
  108    108   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  109    109   
    fn serialize_members(
  110    110   
        &self,
  111    111   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  112    112   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  113    113   
        {
  114    114   
            let val = &self.item;
  115    115   
  116    116   
            ser.write_map(&PUT_MEMBER_ITEM, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  117    117   
                for (key, value) in val {
  118    118   
                    ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  119         -
                    todo!("schema: unsupported map value type");
         119  +
                    ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
  120    120   
                }
  121    121   
                Ok(())
  122    122   
            })?;
  123    123   
        }
  124    124   
        {
  125    125   
            let val = &self.table_name;
  126    126   
            ser.write_string(&PUT_MEMBER_TABLE_NAME, val)?;
  127    127   
        }
  128    128   
        if let Some(ref val) = self.condition_expression {
  129    129   
            ser.write_string(&PUT_MEMBER_CONDITION_EXPRESSION, val)?;
  130    130   
        }
  131    131   
        if let Some(ref val) = self.expression_attribute_names {
  132    132   
            ser.write_map(
  133    133   
                &PUT_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
  134    134   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  135    135   
                    for (key, value) in val {
  136    136   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  137    137   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
  138    138   
                    }
  139    139   
                    Ok(())
  140    140   
                },
  141    141   
            )?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.expression_attribute_values {
  144    144   
            ser.write_map(
  145    145   
                &PUT_MEMBER_EXPRESSION_ATTRIBUTE_VALUES,
  146    146   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  147    147   
                    for (key, value) in val {
  148    148   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  149         -
                        todo!("schema: unsupported map value type");
         149  +
                        ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
  150    150   
                    }
  151    151   
                    Ok(())
  152    152   
                },
  153    153   
            )?;
  154    154   
        }
  155    155   
        if let Some(ref val) = self.return_values_on_condition_check_failure {
  156    156   
            ser.write_string(&PUT_MEMBER_RETURN_VALUES_ON_CONDITION_CHECK_FAILURE, val.as_str())?;
  157    157   
        }
  158    158   
        Ok(())
  159    159   
    }
  160    160   
}
  161    161   
impl Put {
  162    162   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  163         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  164         -
        deserializer: &mut D,
         163  +
    pub fn deserialize(
         164  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  165    165   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  166    166   
        #[allow(unused_variables, unused_mut)]
  167    167   
        let mut builder = Self::builder();
  168    168   
        #[allow(
  169    169   
            unused_variables,
  170    170   
            unreachable_code,
  171    171   
            clippy::single_match,
  172    172   
            clippy::match_single_binding,
  173    173   
            clippy::diverging_sub_expression
  174    174   
        )]
  175         -
        deserializer.read_struct(&PUT_SCHEMA, (), |_, member, deser| {
         175  +
        deserializer.read_struct(&PUT_SCHEMA, &mut |member, deser| {
  176    176   
            match member.member_index() {
  177    177   
                Some(0) => {
  178    178   
                    builder.item = Some({
  179         -
                        let container = if let Some(cap) = deser.container_size() {
  180         -
                            std::collections::HashMap::with_capacity(cap)
  181         -
                        } else {
  182         -
                            std::collections::HashMap::new()
  183         -
                        };
  184         -
                        deser.read_map(member, container, |mut map, key, deser| {
  185         -
                            map.insert(key, todo!("deserialize nested aggregate"));
  186         -
                            Ok(map)
  187         -
                        })?
         179  +
                        let mut container = std::collections::HashMap::new();
         180  +
                        deser.read_map(member, &mut |key, deser| {
         181  +
                            container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
         182  +
                            Ok(())
         183  +
                        })?;
         184  +
                        container
  188    185   
                    });
  189    186   
                }
  190    187   
                Some(1) => {
  191    188   
                    builder.table_name = Some(deser.read_string(member)?);
  192    189   
                }
  193    190   
                Some(2) => {
  194    191   
                    builder.condition_expression = Some(deser.read_string(member)?);
  195    192   
                }
  196    193   
                Some(3) => {
  197         -
                    builder.expression_attribute_names = Some({
  198         -
                        let container = if let Some(cap) = deser.container_size() {
  199         -
                            std::collections::HashMap::with_capacity(cap)
  200         -
                        } else {
  201         -
                            std::collections::HashMap::new()
  202         -
                        };
  203         -
                        deser.read_map(member, container, |mut map, key, deser| {
  204         -
                            map.insert(key, deser.read_string(member)?);
  205         -
                            Ok(map)
  206         -
                        })?
  207         -
                    });
         194  +
                    builder.expression_attribute_names = Some(deser.read_string_string_map(member)?);
  208    195   
                }
  209    196   
                Some(4) => {
  210    197   
                    builder.expression_attribute_values = Some({
  211         -
                        let container = if let Some(cap) = deser.container_size() {
  212         -
                            std::collections::HashMap::with_capacity(cap)
  213         -
                        } else {
  214         -
                            std::collections::HashMap::new()
  215         -
                        };
  216         -
                        deser.read_map(member, container, |mut map, key, deser| {
  217         -
                            map.insert(key, todo!("deserialize nested aggregate"));
  218         -
                            Ok(map)
  219         -
                        })?
         198  +
                        let mut container = std::collections::HashMap::new();
         199  +
                        deser.read_map(member, &mut |key, deser| {
         200  +
                            container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
         201  +
                            Ok(())
         202  +
                        })?;
         203  +
                        container
  220    204   
                    });
  221    205   
                }
  222    206   
                Some(5) => {
  223    207   
                    builder.return_values_on_condition_check_failure = Some(crate::types::ReturnValuesOnConditionCheckFailure::from(
  224    208   
                        deser.read_string(member)?.as_str(),
  225    209   
                    ));
  226    210   
                }
  227    211   
                _ => {}
  228    212   
            }
  229    213   
            Ok(())
  230    214   
        })?;
         215  +
        builder.item = builder.item.or(Some(::std::collections::HashMap::new()));
         216  +
        builder.table_name = builder.table_name.or(Some(String::new()));
  231    217   
        builder
  232    218   
            .build()
  233    219   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  234    220   
    }
  235    221   
}
         222  +
impl Put {
         223  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         224  +
    pub fn deserialize_with_response(
         225  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         226  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         227  +
        _status: u16,
         228  +
        _body: &[u8],
         229  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         230  +
        Self::deserialize(deserializer)
         231  +
    }
         232  +
}
  236    233   
impl Put {
  237    234   
    /// Creates a new builder-style object to manufacture [`Put`](crate::types::Put).
  238    235   
    pub fn builder() -> crate::types::builders::PutBuilder {
  239    236   
        crate::types::builders::PutBuilder::default()
  240    237   
    }
  241    238   
}
  242    239   
  243    240   
/// A builder for [`Put`](crate::types::Put).
  244    241   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  245    242   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_put_request.rs

@@ -1,1 +120,129 @@
   11     11   
    /// <p>A map of attribute name to attribute values, representing the primary key of an item to be processed by <code>PutItem</code>. All of the table's primary key attributes must be specified, and their data types must match those of the table's key schema. If any attributes are present in the item that are part of an index key schema for the table, their types must match the index key schema.</p>
   12     12   
    pub fn item(&self) -> &::std::collections::HashMap<::std::string::String, crate::types::AttributeValue> {
   13     13   
        &self.item
   14     14   
    }
   15     15   
}
   16     16   
static PUTREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#PutRequest", "com.amazonaws.dynamodb", "PutRequest");
   18     18   
static PUTREQUEST_MEMBER_ITEM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#PutRequest$Item", "com.amazonaws.dynamodb", "PutRequest"),
   20     20   
    ::aws_smithy_schema::ShapeType::Map,
   21         -
    "item",
          21  +
    "Item",
   22     22   
    0,
   23     23   
);
   24     24   
static PUTREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   25     25   
    PUTREQUEST_SCHEMA_ID,
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    &[&PUTREQUEST_MEMBER_ITEM],
   28     28   
);
   29     29   
impl PutRequest {
   30     30   
    /// The schema for this shape.
   31     31   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTREQUEST_SCHEMA;
   32     32   
}
   33     33   
impl ::aws_smithy_schema::serde::SerializableStruct for PutRequest {
   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.item;
   41     41   
   42     42   
            ser.write_map(&PUTREQUEST_MEMBER_ITEM, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   43     43   
                for (key, value) in val {
   44     44   
                    ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   45         -
                    todo!("schema: unsupported map value type");
          45  +
                    ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
   46     46   
                }
   47     47   
                Ok(())
   48     48   
            })?;
   49     49   
        }
   50     50   
        Ok(())
   51     51   
    }
   52     52   
}
   53     53   
impl PutRequest {
   54     54   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   55         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   56         -
        deserializer: &mut D,
          55  +
    pub fn deserialize(
          56  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   57     57   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   58     58   
        #[allow(unused_variables, unused_mut)]
   59     59   
        let mut builder = Self::builder();
   60     60   
        #[allow(
   61     61   
            unused_variables,
   62     62   
            unreachable_code,
   63     63   
            clippy::single_match,
   64     64   
            clippy::match_single_binding,
   65     65   
            clippy::diverging_sub_expression
   66     66   
        )]
   67         -
        deserializer.read_struct(&PUTREQUEST_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&PUTREQUEST_SCHEMA, &mut |member, deser| {
   68     68   
            match member.member_index() {
   69     69   
                Some(0) => {
   70     70   
                    builder.item = Some({
   71         -
                        let container = if let Some(cap) = deser.container_size() {
   72         -
                            std::collections::HashMap::with_capacity(cap)
   73         -
                        } else {
   74         -
                            std::collections::HashMap::new()
   75         -
                        };
   76         -
                        deser.read_map(member, container, |mut map, key, deser| {
   77         -
                            map.insert(key, todo!("deserialize nested aggregate"));
   78         -
                            Ok(map)
   79         -
                        })?
          71  +
                        let mut container = std::collections::HashMap::new();
          72  +
                        deser.read_map(member, &mut |key, deser| {
          73  +
                            container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
          74  +
                            Ok(())
          75  +
                        })?;
          76  +
                        container
   80     77   
                    });
   81     78   
                }
   82     79   
                _ => {}
   83     80   
            }
   84     81   
            Ok(())
   85     82   
        })?;
          83  +
        builder.item = builder.item.or(Some(::std::collections::HashMap::new()));
   86     84   
        builder
   87     85   
            .build()
   88     86   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   89     87   
    }
   90     88   
}
          89  +
impl PutRequest {
          90  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          91  +
    pub fn deserialize_with_response(
          92  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          93  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          94  +
        _status: u16,
          95  +
        _body: &[u8],
          96  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          97  +
        Self::deserialize(deserializer)
          98  +
    }
          99  +
}
   91    100   
impl PutRequest {
   92    101   
    /// Creates a new builder-style object to manufacture [`PutRequest`](crate::types::PutRequest).
   93    102   
    pub fn builder() -> crate::types::builders::PutRequestBuilder {
   94    103   
        crate::types::builders::PutRequestBuilder::default()
   95    104   
    }
   96    105   
}
   97    106   
   98    107   
/// A builder for [`PutRequest`](crate::types::PutRequest).
   99    108   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  100    109   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_replica.rs

@@ -1,1 +100,111 @@
   11     11   
    /// <p>The Region where the replica needs to be created.</p>
   12     12   
    pub fn region_name(&self) -> ::std::option::Option<&str> {
   13     13   
        self.region_name.as_deref()
   14     14   
    }
   15     15   
}
   16     16   
static REPLICA_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Replica", "com.amazonaws.dynamodb", "Replica");
   18     18   
static REPLICA_MEMBER_REGION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Replica$RegionName", "com.amazonaws.dynamodb", "Replica"),
   20     20   
    ::aws_smithy_schema::ShapeType::String,
   21         -
    "region_name",
          21  +
    "RegionName",
   22     22   
    0,
   23     23   
);
   24     24   
static REPLICA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   25     25   
    REPLICA_SCHEMA_ID,
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    &[&REPLICA_MEMBER_REGION_NAME],
   28     28   
);
   29     29   
impl Replica {
   30     30   
    /// The schema for this shape.
   31     31   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REPLICA_SCHEMA;
   32     32   
}
   33     33   
impl ::aws_smithy_schema::serde::SerializableStruct for Replica {
   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.region_name {
   40     40   
            ser.write_string(&REPLICA_MEMBER_REGION_NAME, val)?;
   41     41   
        }
   42     42   
        Ok(())
   43     43   
    }
   44     44   
}
   45     45   
impl Replica {
   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(&REPLICA_SCHEMA, (), |_, member, deser| {
          59  +
        deserializer.read_struct(&REPLICA_SCHEMA, &mut |member, deser| {
   60     60   
            match member.member_index() {
   61     61   
                Some(0) => {
   62     62   
                    builder.region_name = 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 Replica {
          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 Replica {
   72     83   
    /// Creates a new builder-style object to manufacture [`Replica`](crate::types::Replica).
   73     84   
    pub fn builder() -> crate::types::builders::ReplicaBuilder {
   74     85   
        crate::types::builders::ReplicaBuilder::default()
   75     86   
    }
   76     87   
}
   77     88   
   78     89   
/// A builder for [`Replica`](crate::types::Replica).
   79     90   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   80     91   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_replica_auto_scaling_description.rs

@@ -44,44 +251,259 @@
   64     64   
    "com.amazonaws.dynamodb",
   65     65   
    "ReplicaAutoScalingDescription",
   66     66   
);
   67     67   
static REPLICAAUTOSCALINGDESCRIPTION_MEMBER_REGION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.dynamodb#ReplicaAutoScalingDescription$RegionName",
   70     70   
        "com.amazonaws.dynamodb",
   71     71   
        "ReplicaAutoScalingDescription",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::String,
   74         -
    "region_name",
          74  +
    "RegionName",
   75     75   
    0,
   76     76   
);
   77     77   
static REPLICAAUTOSCALINGDESCRIPTION_MEMBER_GLOBAL_SECONDARY_INDEXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.dynamodb#ReplicaAutoScalingDescription$GlobalSecondaryIndexes",
   80     80   
        "com.amazonaws.dynamodb",
   81     81   
        "ReplicaAutoScalingDescription",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::List,
   84         -
    "global_secondary_indexes",
          84  +
    "GlobalSecondaryIndexes",
   85     85   
    1,
   86     86   
);
   87     87   
static REPLICAAUTOSCALINGDESCRIPTION_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_AUTO_SCALING_SETTINGS: ::aws_smithy_schema::Schema =
   88     88   
    ::aws_smithy_schema::Schema::new_member(
   89     89   
        ::aws_smithy_schema::ShapeId::from_static(
   90     90   
            "com.amazonaws.dynamodb#ReplicaAutoScalingDescription$ReplicaProvisionedReadCapacityAutoScalingSettings",
   91     91   
            "com.amazonaws.dynamodb",
   92     92   
            "ReplicaAutoScalingDescription",
   93     93   
        ),
   94     94   
        ::aws_smithy_schema::ShapeType::Structure,
   95         -
        "replica_provisioned_read_capacity_auto_scaling_settings",
          95  +
        "ReplicaProvisionedReadCapacityAutoScalingSettings",
   96     96   
        2,
   97     97   
    );
   98     98   
static REPLICAAUTOSCALINGDESCRIPTION_MEMBER_REPLICA_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_SETTINGS: ::aws_smithy_schema::Schema =
   99     99   
    ::aws_smithy_schema::Schema::new_member(
  100    100   
        ::aws_smithy_schema::ShapeId::from_static(
  101    101   
            "com.amazonaws.dynamodb#ReplicaAutoScalingDescription$ReplicaProvisionedWriteCapacityAutoScalingSettings",
  102    102   
            "com.amazonaws.dynamodb",
  103    103   
            "ReplicaAutoScalingDescription",
  104    104   
        ),
  105    105   
        ::aws_smithy_schema::ShapeType::Structure,
  106         -
        "replica_provisioned_write_capacity_auto_scaling_settings",
         106  +
        "ReplicaProvisionedWriteCapacityAutoScalingSettings",
  107    107   
        3,
  108    108   
    );
  109    109   
static REPLICAAUTOSCALINGDESCRIPTION_MEMBER_REPLICA_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.dynamodb#ReplicaAutoScalingDescription$ReplicaStatus",
  112    112   
        "com.amazonaws.dynamodb",
  113    113   
        "ReplicaAutoScalingDescription",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "replica_status",
         116  +
    "ReplicaStatus",
  117    117   
    4,
  118    118   
);
  119    119   
static REPLICAAUTOSCALINGDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  120    120   
    REPLICAAUTOSCALINGDESCRIPTION_SCHEMA_ID,
  121    121   
    ::aws_smithy_schema::ShapeType::Structure,
  122    122   
    &[
  123    123   
        &REPLICAAUTOSCALINGDESCRIPTION_MEMBER_REGION_NAME,
  124    124   
        &REPLICAAUTOSCALINGDESCRIPTION_MEMBER_GLOBAL_SECONDARY_INDEXES,
  125    125   
        &REPLICAAUTOSCALINGDESCRIPTION_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_AUTO_SCALING_SETTINGS,
  126    126   
        &REPLICAAUTOSCALINGDESCRIPTION_MEMBER_REPLICA_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_SETTINGS,
  127    127   
        &REPLICAAUTOSCALINGDESCRIPTION_MEMBER_REPLICA_STATUS,
  128    128   
    ],
  129    129   
);
  130    130   
impl ReplicaAutoScalingDescription {
  131    131   
    /// The schema for this shape.
  132    132   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REPLICAAUTOSCALINGDESCRIPTION_SCHEMA;
  133    133   
}
  134    134   
impl ::aws_smithy_schema::serde::SerializableStruct for ReplicaAutoScalingDescription {
  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   
        if let Some(ref val) = self.region_name {
  141    141   
            ser.write_string(&REPLICAAUTOSCALINGDESCRIPTION_MEMBER_REGION_NAME, val)?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.global_secondary_indexes {
  144    144   
            ser.write_list(
  145    145   
                &REPLICAAUTOSCALINGDESCRIPTION_MEMBER_GLOBAL_SECONDARY_INDEXES,
  146    146   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  147    147   
                    for item in val {
  148    148   
                        ser.write_struct(crate::types::ReplicaGlobalSecondaryIndexAutoScalingDescription::SCHEMA, item)?;
  149    149   
                    }
  150    150   
                    Ok(())
  151    151   
                },
  152    152   
            )?;
  153    153   
        }
  154    154   
        if let Some(ref val) = self.replica_provisioned_read_capacity_auto_scaling_settings {
  155    155   
            ser.write_struct(
  156    156   
                &REPLICAAUTOSCALINGDESCRIPTION_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_AUTO_SCALING_SETTINGS,
  157    157   
                val,
  158    158   
            )?;
  159    159   
        }
  160    160   
        if let Some(ref val) = self.replica_provisioned_write_capacity_auto_scaling_settings {
  161    161   
            ser.write_struct(
  162    162   
                &REPLICAAUTOSCALINGDESCRIPTION_MEMBER_REPLICA_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_SETTINGS,
  163    163   
                val,
  164    164   
            )?;
  165    165   
        }
  166    166   
        if let Some(ref val) = self.replica_status {
  167    167   
            ser.write_string(&REPLICAAUTOSCALINGDESCRIPTION_MEMBER_REPLICA_STATUS, val.as_str())?;
  168    168   
        }
  169    169   
        Ok(())
  170    170   
    }
  171    171   
}
  172    172   
impl ReplicaAutoScalingDescription {
  173    173   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  174         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  175         -
        deserializer: &mut D,
         174  +
    pub fn deserialize(
         175  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  176    176   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  177    177   
        #[allow(unused_variables, unused_mut)]
  178    178   
        let mut builder = Self::builder();
  179    179   
        #[allow(
  180    180   
            unused_variables,
  181    181   
            unreachable_code,
  182    182   
            clippy::single_match,
  183    183   
            clippy::match_single_binding,
  184    184   
            clippy::diverging_sub_expression
  185    185   
        )]
  186         -
        deserializer.read_struct(&REPLICAAUTOSCALINGDESCRIPTION_SCHEMA, (), |_, member, deser| {
         186  +
        deserializer.read_struct(&REPLICAAUTOSCALINGDESCRIPTION_SCHEMA, &mut |member, deser| {
  187    187   
            match member.member_index() {
  188    188   
                Some(0) => {
  189    189   
                    builder.region_name = Some(deser.read_string(member)?);
  190    190   
                }
  191    191   
                Some(1) => {
  192    192   
                    builder.global_secondary_indexes = Some({
  193         -
                        let container = if let Some(cap) = deser.container_size() {
  194         -
                            Vec::with_capacity(cap)
  195         -
                        } else {
  196         -
                            Vec::new()
  197         -
                        };
  198         -
                        deser.read_list(member, container, |mut list, deser| {
  199         -
                            list.push(crate::types::ReplicaGlobalSecondaryIndexAutoScalingDescription::deserialize(deser)?);
  200         -
                            Ok(list)
  201         -
                        })?
         193  +
                        let mut container = Vec::new();
         194  +
                        deser.read_list(member, &mut |deser| {
         195  +
                            container.push(crate::types::ReplicaGlobalSecondaryIndexAutoScalingDescription::deserialize(deser)?);
         196  +
                            Ok(())
         197  +
                        })?;
         198  +
                        container
  202    199   
                    });
  203    200   
                }
  204    201   
                Some(2) => {
  205    202   
                    builder.replica_provisioned_read_capacity_auto_scaling_settings =
  206    203   
                        Some(crate::types::AutoScalingSettingsDescription::deserialize(deser)?);
  207    204   
                }
  208    205   
                Some(3) => {
  209    206   
                    builder.replica_provisioned_write_capacity_auto_scaling_settings =
  210    207   
                        Some(crate::types::AutoScalingSettingsDescription::deserialize(deser)?);
  211    208   
                }
  212    209   
                Some(4) => {
  213    210   
                    builder.replica_status = Some(crate::types::ReplicaStatus::from(deser.read_string(member)?.as_str()));
  214    211   
                }
  215    212   
                _ => {}
  216    213   
            }
  217    214   
            Ok(())
  218    215   
        })?;
  219    216   
        Ok(builder.build())
  220    217   
    }
  221    218   
}
         219  +
impl ReplicaAutoScalingDescription {
         220  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         221  +
    pub fn deserialize_with_response(
         222  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         223  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         224  +
        _status: u16,
         225  +
        _body: &[u8],
         226  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         227  +
        Self::deserialize(deserializer)
         228  +
    }
         229  +
}
  222    230   
impl ReplicaAutoScalingDescription {
  223    231   
    /// Creates a new builder-style object to manufacture [`ReplicaAutoScalingDescription`](crate::types::ReplicaAutoScalingDescription).
  224    232   
    pub fn builder() -> crate::types::builders::ReplicaAutoScalingDescriptionBuilder {
  225    233   
        crate::types::builders::ReplicaAutoScalingDescriptionBuilder::default()
  226    234   
    }
  227    235   
}
  228    236   
  229    237   
/// A builder for [`ReplicaAutoScalingDescription`](crate::types::ReplicaAutoScalingDescription).
  230    238   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  231    239   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_replica_auto_scaling_update.rs

@@ -13,13 +184,193 @@
   33     33   
    "com.amazonaws.dynamodb",
   34     34   
    "ReplicaAutoScalingUpdate",
   35     35   
);
   36     36   
static REPLICAAUTOSCALINGUPDATE_MEMBER_REGION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static(
   38     38   
        "com.amazonaws.dynamodb#ReplicaAutoScalingUpdate$RegionName",
   39     39   
        "com.amazonaws.dynamodb",
   40     40   
        "ReplicaAutoScalingUpdate",
   41     41   
    ),
   42     42   
    ::aws_smithy_schema::ShapeType::String,
   43         -
    "region_name",
          43  +
    "RegionName",
   44     44   
    0,
   45     45   
);
   46     46   
static REPLICAAUTOSCALINGUPDATE_MEMBER_REPLICA_GLOBAL_SECONDARY_INDEX_UPDATES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   47     47   
    ::aws_smithy_schema::ShapeId::from_static(
   48     48   
        "com.amazonaws.dynamodb#ReplicaAutoScalingUpdate$ReplicaGlobalSecondaryIndexUpdates",
   49     49   
        "com.amazonaws.dynamodb",
   50     50   
        "ReplicaAutoScalingUpdate",
   51     51   
    ),
   52     52   
    ::aws_smithy_schema::ShapeType::List,
   53         -
    "replica_global_secondary_index_updates",
          53  +
    "ReplicaGlobalSecondaryIndexUpdates",
   54     54   
    1,
   55     55   
);
   56     56   
static REPLICAAUTOSCALINGUPDATE_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_AUTO_SCALING_UPDATE: ::aws_smithy_schema::Schema =
   57     57   
    ::aws_smithy_schema::Schema::new_member(
   58     58   
        ::aws_smithy_schema::ShapeId::from_static(
   59     59   
            "com.amazonaws.dynamodb#ReplicaAutoScalingUpdate$ReplicaProvisionedReadCapacityAutoScalingUpdate",
   60     60   
            "com.amazonaws.dynamodb",
   61     61   
            "ReplicaAutoScalingUpdate",
   62     62   
        ),
   63     63   
        ::aws_smithy_schema::ShapeType::Structure,
   64         -
        "replica_provisioned_read_capacity_auto_scaling_update",
          64  +
        "ReplicaProvisionedReadCapacityAutoScalingUpdate",
   65     65   
        2,
   66     66   
    );
   67     67   
static REPLICAAUTOSCALINGUPDATE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   68     68   
    REPLICAAUTOSCALINGUPDATE_SCHEMA_ID,
   69     69   
    ::aws_smithy_schema::ShapeType::Structure,
   70     70   
    &[
   71     71   
        &REPLICAAUTOSCALINGUPDATE_MEMBER_REGION_NAME,
   72     72   
        &REPLICAAUTOSCALINGUPDATE_MEMBER_REPLICA_GLOBAL_SECONDARY_INDEX_UPDATES,
   73     73   
        &REPLICAAUTOSCALINGUPDATE_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_AUTO_SCALING_UPDATE,
   74     74   
    ],
   75     75   
);
   76     76   
impl ReplicaAutoScalingUpdate {
   77     77   
    /// The schema for this shape.
   78     78   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REPLICAAUTOSCALINGUPDATE_SCHEMA;
   79     79   
}
   80     80   
impl ::aws_smithy_schema::serde::SerializableStruct for ReplicaAutoScalingUpdate {
   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   
        {
   87     87   
            let val = &self.region_name;
   88     88   
            ser.write_string(&REPLICAAUTOSCALINGUPDATE_MEMBER_REGION_NAME, val)?;
   89     89   
        }
   90     90   
        if let Some(ref val) = self.replica_global_secondary_index_updates {
   91     91   
            ser.write_list(
   92     92   
                &REPLICAAUTOSCALINGUPDATE_MEMBER_REPLICA_GLOBAL_SECONDARY_INDEX_UPDATES,
   93     93   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   94     94   
                    for item in val {
   95     95   
                        ser.write_struct(crate::types::ReplicaGlobalSecondaryIndexAutoScalingUpdate::SCHEMA, item)?;
   96     96   
                    }
   97     97   
                    Ok(())
   98     98   
                },
   99     99   
            )?;
  100    100   
        }
  101    101   
        if let Some(ref val) = self.replica_provisioned_read_capacity_auto_scaling_update {
  102    102   
            ser.write_struct(
  103    103   
                &REPLICAAUTOSCALINGUPDATE_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_AUTO_SCALING_UPDATE,
  104    104   
                val,
  105    105   
            )?;
  106    106   
        }
  107    107   
        Ok(())
  108    108   
    }
  109    109   
}
  110    110   
impl ReplicaAutoScalingUpdate {
  111    111   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  112         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  113         -
        deserializer: &mut D,
         112  +
    pub fn deserialize(
         113  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  114    114   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  115    115   
        #[allow(unused_variables, unused_mut)]
  116    116   
        let mut builder = Self::builder();
  117    117   
        #[allow(
  118    118   
            unused_variables,
  119    119   
            unreachable_code,
  120    120   
            clippy::single_match,
  121    121   
            clippy::match_single_binding,
  122    122   
            clippy::diverging_sub_expression
  123    123   
        )]
  124         -
        deserializer.read_struct(&REPLICAAUTOSCALINGUPDATE_SCHEMA, (), |_, member, deser| {
         124  +
        deserializer.read_struct(&REPLICAAUTOSCALINGUPDATE_SCHEMA, &mut |member, deser| {
  125    125   
            match member.member_index() {
  126    126   
                Some(0) => {
  127    127   
                    builder.region_name = Some(deser.read_string(member)?);
  128    128   
                }
  129    129   
                Some(1) => {
  130    130   
                    builder.replica_global_secondary_index_updates = Some({
  131         -
                        let container = if let Some(cap) = deser.container_size() {
  132         -
                            Vec::with_capacity(cap)
  133         -
                        } else {
  134         -
                            Vec::new()
  135         -
                        };
  136         -
                        deser.read_list(member, container, |mut list, deser| {
  137         -
                            list.push(crate::types::ReplicaGlobalSecondaryIndexAutoScalingUpdate::deserialize(deser)?);
  138         -
                            Ok(list)
  139         -
                        })?
         131  +
                        let mut container = Vec::new();
         132  +
                        deser.read_list(member, &mut |deser| {
         133  +
                            container.push(crate::types::ReplicaGlobalSecondaryIndexAutoScalingUpdate::deserialize(deser)?);
         134  +
                            Ok(())
         135  +
                        })?;
         136  +
                        container
  140    137   
                    });
  141    138   
                }
  142    139   
                Some(2) => {
  143    140   
                    builder.replica_provisioned_read_capacity_auto_scaling_update =
  144    141   
                        Some(crate::types::AutoScalingSettingsUpdate::deserialize(deser)?);
  145    142   
                }
  146    143   
                _ => {}
  147    144   
            }
  148    145   
            Ok(())
  149    146   
        })?;
         147  +
        builder.region_name = builder.region_name.or(Some(String::new()));
  150    148   
        builder
  151    149   
            .build()
  152    150   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  153    151   
    }
  154    152   
}
         153  +
impl ReplicaAutoScalingUpdate {
         154  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         155  +
    pub fn deserialize_with_response(
         156  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         157  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         158  +
        _status: u16,
         159  +
        _body: &[u8],
         160  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         161  +
        Self::deserialize(deserializer)
         162  +
    }
         163  +
}
  155    164   
impl ReplicaAutoScalingUpdate {
  156    165   
    /// Creates a new builder-style object to manufacture [`ReplicaAutoScalingUpdate`](crate::types::ReplicaAutoScalingUpdate).
  157    166   
    pub fn builder() -> crate::types::builders::ReplicaAutoScalingUpdateBuilder {
  158    167   
        crate::types::builders::ReplicaAutoScalingUpdateBuilder::default()
  159    168   
    }
  160    169   
}
  161    170   
  162    171   
/// A builder for [`ReplicaAutoScalingUpdate`](crate::types::ReplicaAutoScalingUpdate).
  163    172   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  164    173   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_replica_description.rs

@@ -96,96 +256,256 @@
  116    116   
    "com.amazonaws.dynamodb",
  117    117   
    "ReplicaDescription",
  118    118   
);
  119    119   
static REPLICADESCRIPTION_MEMBER_REGION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.dynamodb#ReplicaDescription$RegionName",
  122    122   
        "com.amazonaws.dynamodb",
  123    123   
        "ReplicaDescription",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::String,
  126         -
    "region_name",
         126  +
    "RegionName",
  127    127   
    0,
  128    128   
);
  129    129   
static REPLICADESCRIPTION_MEMBER_REPLICA_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static(
  131    131   
        "com.amazonaws.dynamodb#ReplicaDescription$ReplicaStatus",
  132    132   
        "com.amazonaws.dynamodb",
  133    133   
        "ReplicaDescription",
  134    134   
    ),
  135    135   
    ::aws_smithy_schema::ShapeType::String,
  136         -
    "replica_status",
         136  +
    "ReplicaStatus",
  137    137   
    1,
  138    138   
);
  139    139   
static REPLICADESCRIPTION_MEMBER_REPLICA_STATUS_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static(
  141    141   
        "com.amazonaws.dynamodb#ReplicaDescription$ReplicaStatusDescription",
  142    142   
        "com.amazonaws.dynamodb",
  143    143   
        "ReplicaDescription",
  144    144   
    ),
  145    145   
    ::aws_smithy_schema::ShapeType::String,
  146         -
    "replica_status_description",
         146  +
    "ReplicaStatusDescription",
  147    147   
    2,
  148    148   
);
  149    149   
static REPLICADESCRIPTION_MEMBER_REPLICA_STATUS_PERCENT_PROGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static(
  151    151   
        "com.amazonaws.dynamodb#ReplicaDescription$ReplicaStatusPercentProgress",
  152    152   
        "com.amazonaws.dynamodb",
  153    153   
        "ReplicaDescription",
  154    154   
    ),
  155    155   
    ::aws_smithy_schema::ShapeType::String,
  156         -
    "replica_status_percent_progress",
         156  +
    "ReplicaStatusPercentProgress",
  157    157   
    3,
  158    158   
);
  159    159   
static REPLICADESCRIPTION_MEMBER_KMS_MASTER_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  160    160   
    ::aws_smithy_schema::ShapeId::from_static(
  161    161   
        "com.amazonaws.dynamodb#ReplicaDescription$KMSMasterKeyId",
  162    162   
        "com.amazonaws.dynamodb",
  163    163   
        "ReplicaDescription",
  164    164   
    ),
  165    165   
    ::aws_smithy_schema::ShapeType::String,
  166         -
    "kms_master_key_id",
         166  +
    "KMSMasterKeyId",
  167    167   
    4,
  168    168   
);
  169    169   
static REPLICADESCRIPTION_MEMBER_PROVISIONED_THROUGHPUT_OVERRIDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  170    170   
    ::aws_smithy_schema::ShapeId::from_static(
  171    171   
        "com.amazonaws.dynamodb#ReplicaDescription$ProvisionedThroughputOverride",
  172    172   
        "com.amazonaws.dynamodb",
  173    173   
        "ReplicaDescription",
  174    174   
    ),
  175    175   
    ::aws_smithy_schema::ShapeType::Structure,
  176         -
    "provisioned_throughput_override",
         176  +
    "ProvisionedThroughputOverride",
  177    177   
    5,
  178    178   
);
  179    179   
static REPLICADESCRIPTION_MEMBER_ON_DEMAND_THROUGHPUT_OVERRIDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  180    180   
    ::aws_smithy_schema::ShapeId::from_static(
  181    181   
        "com.amazonaws.dynamodb#ReplicaDescription$OnDemandThroughputOverride",
  182    182   
        "com.amazonaws.dynamodb",
  183    183   
        "ReplicaDescription",
  184    184   
    ),
  185    185   
    ::aws_smithy_schema::ShapeType::Structure,
  186         -
    "on_demand_throughput_override",
         186  +
    "OnDemandThroughputOverride",
  187    187   
    6,
  188    188   
);
  189    189   
static REPLICADESCRIPTION_MEMBER_WARM_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  190    190   
    ::aws_smithy_schema::ShapeId::from_static(
  191    191   
        "com.amazonaws.dynamodb#ReplicaDescription$WarmThroughput",
  192    192   
        "com.amazonaws.dynamodb",
  193    193   
        "ReplicaDescription",
  194    194   
    ),
  195    195   
    ::aws_smithy_schema::ShapeType::Structure,
  196         -
    "warm_throughput",
         196  +
    "WarmThroughput",
  197    197   
    7,
  198    198   
);
  199    199   
static REPLICADESCRIPTION_MEMBER_GLOBAL_SECONDARY_INDEXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  200    200   
    ::aws_smithy_schema::ShapeId::from_static(
  201    201   
        "com.amazonaws.dynamodb#ReplicaDescription$GlobalSecondaryIndexes",
  202    202   
        "com.amazonaws.dynamodb",
  203    203   
        "ReplicaDescription",
  204    204   
    ),
  205    205   
    ::aws_smithy_schema::ShapeType::List,
  206         -
    "global_secondary_indexes",
         206  +
    "GlobalSecondaryIndexes",
  207    207   
    8,
  208    208   
);
  209    209   
static REPLICADESCRIPTION_MEMBER_REPLICA_INACCESSIBLE_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  210    210   
    ::aws_smithy_schema::ShapeId::from_static(
  211    211   
        "com.amazonaws.dynamodb#ReplicaDescription$ReplicaInaccessibleDateTime",
  212    212   
        "com.amazonaws.dynamodb",
  213    213   
        "ReplicaDescription",
  214    214   
    ),
  215    215   
    ::aws_smithy_schema::ShapeType::Timestamp,
  216         -
    "replica_inaccessible_date_time",
         216  +
    "ReplicaInaccessibleDateTime",
  217    217   
    9,
  218    218   
);
  219    219   
static REPLICADESCRIPTION_MEMBER_REPLICA_TABLE_CLASS_SUMMARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  220    220   
    ::aws_smithy_schema::ShapeId::from_static(
  221    221   
        "com.amazonaws.dynamodb#ReplicaDescription$ReplicaTableClassSummary",
  222    222   
        "com.amazonaws.dynamodb",
  223    223   
        "ReplicaDescription",
  224    224   
    ),
  225    225   
    ::aws_smithy_schema::ShapeType::Structure,
  226         -
    "replica_table_class_summary",
         226  +
    "ReplicaTableClassSummary",
  227    227   
    10,
  228    228   
);
  229    229   
static REPLICADESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  230    230   
    REPLICADESCRIPTION_SCHEMA_ID,
  231    231   
    ::aws_smithy_schema::ShapeType::Structure,
  232    232   
    &[
  233    233   
        &REPLICADESCRIPTION_MEMBER_REGION_NAME,
  234    234   
        &REPLICADESCRIPTION_MEMBER_REPLICA_STATUS,
  235    235   
        &REPLICADESCRIPTION_MEMBER_REPLICA_STATUS_DESCRIPTION,
  236    236   
        &REPLICADESCRIPTION_MEMBER_REPLICA_STATUS_PERCENT_PROGRESS,
@@ -272,272 +395,403 @@
  292    292   
            ser.write_timestamp(&REPLICADESCRIPTION_MEMBER_REPLICA_INACCESSIBLE_DATE_TIME, val)?;
  293    293   
        }
  294    294   
        if let Some(ref val) = self.replica_table_class_summary {
  295    295   
            ser.write_struct(&REPLICADESCRIPTION_MEMBER_REPLICA_TABLE_CLASS_SUMMARY, val)?;
  296    296   
        }
  297    297   
        Ok(())
  298    298   
    }
  299    299   
}
  300    300   
impl ReplicaDescription {
  301    301   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  302         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  303         -
        deserializer: &mut D,
         302  +
    pub fn deserialize(
         303  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  304    304   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  305    305   
        #[allow(unused_variables, unused_mut)]
  306    306   
        let mut builder = Self::builder();
  307    307   
        #[allow(
  308    308   
            unused_variables,
  309    309   
            unreachable_code,
  310    310   
            clippy::single_match,
  311    311   
            clippy::match_single_binding,
  312    312   
            clippy::diverging_sub_expression
  313    313   
        )]
  314         -
        deserializer.read_struct(&REPLICADESCRIPTION_SCHEMA, (), |_, member, deser| {
         314  +
        deserializer.read_struct(&REPLICADESCRIPTION_SCHEMA, &mut |member, deser| {
  315    315   
            match member.member_index() {
  316    316   
                Some(0) => {
  317    317   
                    builder.region_name = Some(deser.read_string(member)?);
  318    318   
                }
  319    319   
                Some(1) => {
  320    320   
                    builder.replica_status = Some(crate::types::ReplicaStatus::from(deser.read_string(member)?.as_str()));
  321    321   
                }
  322    322   
                Some(2) => {
  323    323   
                    builder.replica_status_description = Some(deser.read_string(member)?);
  324    324   
                }
  325    325   
                Some(3) => {
  326    326   
                    builder.replica_status_percent_progress = Some(deser.read_string(member)?);
  327    327   
                }
  328    328   
                Some(4) => {
  329    329   
                    builder.kms_master_key_id = Some(deser.read_string(member)?);
  330    330   
                }
  331    331   
                Some(5) => {
  332    332   
                    builder.provisioned_throughput_override = Some(crate::types::ProvisionedThroughputOverride::deserialize(deser)?);
  333    333   
                }
  334    334   
                Some(6) => {
  335    335   
                    builder.on_demand_throughput_override = Some(crate::types::OnDemandThroughputOverride::deserialize(deser)?);
  336    336   
                }
  337    337   
                Some(7) => {
  338    338   
                    builder.warm_throughput = Some(crate::types::TableWarmThroughputDescription::deserialize(deser)?);
  339    339   
                }
  340    340   
                Some(8) => {
  341    341   
                    builder.global_secondary_indexes = Some({
  342         -
                        let container = if let Some(cap) = deser.container_size() {
  343         -
                            Vec::with_capacity(cap)
  344         -
                        } else {
  345         -
                            Vec::new()
  346         -
                        };
  347         -
                        deser.read_list(member, container, |mut list, deser| {
  348         -
                            list.push(crate::types::ReplicaGlobalSecondaryIndexDescription::deserialize(deser)?);
  349         -
                            Ok(list)
  350         -
                        })?
         342  +
                        let mut container = Vec::new();
         343  +
                        deser.read_list(member, &mut |deser| {
         344  +
                            container.push(crate::types::ReplicaGlobalSecondaryIndexDescription::deserialize(deser)?);
         345  +
                            Ok(())
         346  +
                        })?;
         347  +
                        container
  351    348   
                    });
  352    349   
                }
  353    350   
                Some(9) => {
  354    351   
                    builder.replica_inaccessible_date_time = Some(deser.read_timestamp(member)?);
  355    352   
                }
  356    353   
                Some(10) => {
  357    354   
                    builder.replica_table_class_summary = Some(crate::types::TableClassSummary::deserialize(deser)?);
  358    355   
                }
  359    356   
                _ => {}
  360    357   
            }
  361    358   
            Ok(())
  362    359   
        })?;
  363    360   
        Ok(builder.build())
  364    361   
    }
  365    362   
}
         363  +
impl ReplicaDescription {
         364  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         365  +
    pub fn deserialize_with_response(
         366  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         367  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         368  +
        _status: u16,
         369  +
        _body: &[u8],
         370  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         371  +
        Self::deserialize(deserializer)
         372  +
    }
         373  +
}
  366    374   
impl ReplicaDescription {
  367    375   
    /// Creates a new builder-style object to manufacture [`ReplicaDescription`](crate::types::ReplicaDescription).
  368    376   
    pub fn builder() -> crate::types::builders::ReplicaDescriptionBuilder {
  369    377   
        crate::types::builders::ReplicaDescriptionBuilder::default()
  370    378   
    }
  371    379   
}
  372    380   
  373    381   
/// A builder for [`ReplicaDescription`](crate::types::ReplicaDescription).
  374    382   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  375    383   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_replica_global_secondary_index.rs

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_replica_global_secondary_index_auto_scaling_description.rs

@@ -36,36 +207,218 @@
   56     56   
    "com.amazonaws.dynamodb",
   57     57   
    "ReplicaGlobalSecondaryIndexAutoScalingDescription",
   58     58   
);
   59     59   
static REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_MEMBER_INDEX_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.dynamodb#ReplicaGlobalSecondaryIndexAutoScalingDescription$IndexName",
   62     62   
        "com.amazonaws.dynamodb",
   63     63   
        "ReplicaGlobalSecondaryIndexAutoScalingDescription",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "index_name",
          66  +
    "IndexName",
   67     67   
    0,
   68     68   
);
   69     69   
static REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_MEMBER_INDEX_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.dynamodb#ReplicaGlobalSecondaryIndexAutoScalingDescription$IndexStatus",
   72     72   
        "com.amazonaws.dynamodb",
   73     73   
        "ReplicaGlobalSecondaryIndexAutoScalingDescription",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "index_status",
          76  +
    "IndexStatus",
   77     77   
    1,
   78     78   
);
   79     79   
static REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_MEMBER_PROVISIONED_READ_CAPACITY_AUTO_SCALING_SETTINGS: ::aws_smithy_schema::Schema =
   80     80   
    ::aws_smithy_schema::Schema::new_member(
   81     81   
        ::aws_smithy_schema::ShapeId::from_static(
   82     82   
            "com.amazonaws.dynamodb#ReplicaGlobalSecondaryIndexAutoScalingDescription$ProvisionedReadCapacityAutoScalingSettings",
   83     83   
            "com.amazonaws.dynamodb",
   84     84   
            "ReplicaGlobalSecondaryIndexAutoScalingDescription",
   85     85   
        ),
   86     86   
        ::aws_smithy_schema::ShapeType::Structure,
   87         -
        "provisioned_read_capacity_auto_scaling_settings",
          87  +
        "ProvisionedReadCapacityAutoScalingSettings",
   88     88   
        2,
   89     89   
    );
   90     90   
static REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_MEMBER_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_SETTINGS: ::aws_smithy_schema::Schema =
   91     91   
    ::aws_smithy_schema::Schema::new_member(
   92     92   
        ::aws_smithy_schema::ShapeId::from_static(
   93     93   
            "com.amazonaws.dynamodb#ReplicaGlobalSecondaryIndexAutoScalingDescription$ProvisionedWriteCapacityAutoScalingSettings",
   94     94   
            "com.amazonaws.dynamodb",
   95     95   
            "ReplicaGlobalSecondaryIndexAutoScalingDescription",
   96     96   
        ),
   97     97   
        ::aws_smithy_schema::ShapeType::Structure,
   98         -
        "provisioned_write_capacity_auto_scaling_settings",
          98  +
        "ProvisionedWriteCapacityAutoScalingSettings",
   99     99   
        3,
  100    100   
    );
  101    101   
static REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  102    102   
    REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_SCHEMA_ID,
  103    103   
    ::aws_smithy_schema::ShapeType::Structure,
  104    104   
    &[
  105    105   
        &REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_MEMBER_INDEX_NAME,
  106    106   
        &REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_MEMBER_INDEX_STATUS,
  107    107   
        &REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_MEMBER_PROVISIONED_READ_CAPACITY_AUTO_SCALING_SETTINGS,
  108    108   
        &REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_MEMBER_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_SETTINGS,
  109    109   
    ],
  110    110   
);
  111    111   
impl ReplicaGlobalSecondaryIndexAutoScalingDescription {
  112    112   
    /// The schema for this shape.
  113    113   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_SCHEMA;
  114    114   
}
  115    115   
impl ::aws_smithy_schema::serde::SerializableStruct for ReplicaGlobalSecondaryIndexAutoScalingDescription {
  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.index_name {
  122    122   
            ser.write_string(&REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_MEMBER_INDEX_NAME, val)?;
  123    123   
        }
  124    124   
        if let Some(ref val) = self.index_status {
  125    125   
            ser.write_string(&REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_MEMBER_INDEX_STATUS, val.as_str())?;
  126    126   
        }
  127    127   
        if let Some(ref val) = self.provisioned_read_capacity_auto_scaling_settings {
  128    128   
            ser.write_struct(
  129    129   
                &REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_MEMBER_PROVISIONED_READ_CAPACITY_AUTO_SCALING_SETTINGS,
  130    130   
                val,
  131    131   
            )?;
  132    132   
        }
  133    133   
        if let Some(ref val) = self.provisioned_write_capacity_auto_scaling_settings {
  134    134   
            ser.write_struct(
  135    135   
                &REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_MEMBER_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_SETTINGS,
  136    136   
                val,
  137    137   
            )?;
  138    138   
        }
  139    139   
        Ok(())
  140    140   
    }
  141    141   
}
  142    142   
impl ReplicaGlobalSecondaryIndexAutoScalingDescription {
  143    143   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  144         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  145         -
        deserializer: &mut D,
         144  +
    pub fn deserialize(
         145  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  146    146   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  147    147   
        #[allow(unused_variables, unused_mut)]
  148    148   
        let mut builder = Self::builder();
  149    149   
        #[allow(
  150    150   
            unused_variables,
  151    151   
            unreachable_code,
  152    152   
            clippy::single_match,
  153    153   
            clippy::match_single_binding,
  154    154   
            clippy::diverging_sub_expression
  155    155   
        )]
  156         -
        deserializer.read_struct(&REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_SCHEMA, (), |_, member, deser| {
         156  +
        deserializer.read_struct(&REPLICAGLOBALSECONDARYINDEXAUTOSCALINGDESCRIPTION_SCHEMA, &mut |member, deser| {
  157    157   
            match member.member_index() {
  158    158   
                Some(0) => {
  159    159   
                    builder.index_name = Some(deser.read_string(member)?);
  160    160   
                }
  161    161   
                Some(1) => {
  162    162   
                    builder.index_status = Some(crate::types::IndexStatus::from(deser.read_string(member)?.as_str()));
  163    163   
                }
  164    164   
                Some(2) => {
  165    165   
                    builder.provisioned_read_capacity_auto_scaling_settings = Some(crate::types::AutoScalingSettingsDescription::deserialize(deser)?);
  166    166   
                }
  167    167   
                Some(3) => {
  168    168   
                    builder.provisioned_write_capacity_auto_scaling_settings =
  169    169   
                        Some(crate::types::AutoScalingSettingsDescription::deserialize(deser)?);
  170    170   
                }
  171    171   
                _ => {}
  172    172   
            }
  173    173   
            Ok(())
  174    174   
        })?;
  175    175   
        Ok(builder.build())
  176    176   
    }
  177    177   
}
         178  +
impl ReplicaGlobalSecondaryIndexAutoScalingDescription {
         179  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         180  +
    pub fn deserialize_with_response(
         181  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         182  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         183  +
        _status: u16,
         184  +
        _body: &[u8],
         185  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         186  +
        Self::deserialize(deserializer)
         187  +
    }
         188  +
}
  178    189   
impl ReplicaGlobalSecondaryIndexAutoScalingDescription {
  179    190   
    /// Creates a new builder-style object to manufacture [`ReplicaGlobalSecondaryIndexAutoScalingDescription`](crate::types::ReplicaGlobalSecondaryIndexAutoScalingDescription).
  180    191   
    pub fn builder() -> crate::types::builders::ReplicaGlobalSecondaryIndexAutoScalingDescriptionBuilder {
  181    192   
        crate::types::builders::ReplicaGlobalSecondaryIndexAutoScalingDescriptionBuilder::default()
  182    193   
    }
  183    194   
}
  184    195   
  185    196   
/// A builder for [`ReplicaGlobalSecondaryIndexAutoScalingDescription`](crate::types::ReplicaGlobalSecondaryIndexAutoScalingDescription).
  186    197   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  187    198   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_replica_global_secondary_index_auto_scaling_update.rs

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_replica_global_secondary_index_description.rs

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/_replica_global_secondary_index_settings_description.rs

@@ -49,49 +265,277 @@
   69     69   
    "com.amazonaws.dynamodb",
   70     70   
    "ReplicaGlobalSecondaryIndexSettingsDescription",
   71     71   
);
   72     72   
static REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_INDEX_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.dynamodb#ReplicaGlobalSecondaryIndexSettingsDescription$IndexName",
   75     75   
        "com.amazonaws.dynamodb",
   76     76   
        "ReplicaGlobalSecondaryIndexSettingsDescription",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "index_name",
          79  +
    "IndexName",
   80     80   
    0,
   81     81   
);
   82     82   
static REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_INDEX_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.dynamodb#ReplicaGlobalSecondaryIndexSettingsDescription$IndexStatus",
   85     85   
        "com.amazonaws.dynamodb",
   86     86   
        "ReplicaGlobalSecondaryIndexSettingsDescription",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "index_status",
          89  +
    "IndexStatus",
   90     90   
    1,
   91     91   
);
   92     92   
static REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_PROVISIONED_READ_CAPACITY_UNITS: ::aws_smithy_schema::Schema =
   93     93   
    ::aws_smithy_schema::Schema::new_member(
   94     94   
        ::aws_smithy_schema::ShapeId::from_static(
   95     95   
            "com.amazonaws.dynamodb#ReplicaGlobalSecondaryIndexSettingsDescription$ProvisionedReadCapacityUnits",
   96     96   
            "com.amazonaws.dynamodb",
   97     97   
            "ReplicaGlobalSecondaryIndexSettingsDescription",
   98     98   
        ),
   99     99   
        ::aws_smithy_schema::ShapeType::Long,
  100         -
        "provisioned_read_capacity_units",
         100  +
        "ProvisionedReadCapacityUnits",
  101    101   
        2,
  102    102   
    );
  103    103   
static REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_PROVISIONED_READ_CAPACITY_AUTO_SCALING_SETTINGS: ::aws_smithy_schema::Schema =
  104    104   
    ::aws_smithy_schema::Schema::new_member(
  105    105   
        ::aws_smithy_schema::ShapeId::from_static(
  106    106   
            "com.amazonaws.dynamodb#ReplicaGlobalSecondaryIndexSettingsDescription$ProvisionedReadCapacityAutoScalingSettings",
  107    107   
            "com.amazonaws.dynamodb",
  108    108   
            "ReplicaGlobalSecondaryIndexSettingsDescription",
  109    109   
        ),
  110    110   
        ::aws_smithy_schema::ShapeType::Structure,
  111         -
        "provisioned_read_capacity_auto_scaling_settings",
         111  +
        "ProvisionedReadCapacityAutoScalingSettings",
  112    112   
        3,
  113    113   
    );
  114    114   
static REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_PROVISIONED_WRITE_CAPACITY_UNITS: ::aws_smithy_schema::Schema =
  115    115   
    ::aws_smithy_schema::Schema::new_member(
  116    116   
        ::aws_smithy_schema::ShapeId::from_static(
  117    117   
            "com.amazonaws.dynamodb#ReplicaGlobalSecondaryIndexSettingsDescription$ProvisionedWriteCapacityUnits",
  118    118   
            "com.amazonaws.dynamodb",
  119    119   
            "ReplicaGlobalSecondaryIndexSettingsDescription",
  120    120   
        ),
  121    121   
        ::aws_smithy_schema::ShapeType::Long,
  122         -
        "provisioned_write_capacity_units",
         122  +
        "ProvisionedWriteCapacityUnits",
  123    123   
        4,
  124    124   
    );
  125    125   
static REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_SETTINGS: ::aws_smithy_schema::Schema =
  126    126   
    ::aws_smithy_schema::Schema::new_member(
  127    127   
        ::aws_smithy_schema::ShapeId::from_static(
  128    128   
            "com.amazonaws.dynamodb#ReplicaGlobalSecondaryIndexSettingsDescription$ProvisionedWriteCapacityAutoScalingSettings",
  129    129   
            "com.amazonaws.dynamodb",
  130    130   
            "ReplicaGlobalSecondaryIndexSettingsDescription",
  131    131   
        ),
  132    132   
        ::aws_smithy_schema::ShapeType::Structure,
  133         -
        "provisioned_write_capacity_auto_scaling_settings",
         133  +
        "ProvisionedWriteCapacityAutoScalingSettings",
  134    134   
        5,
  135    135   
    );
  136    136   
static REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  137    137   
    REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_SCHEMA_ID,
  138    138   
    ::aws_smithy_schema::ShapeType::Structure,
  139    139   
    &[
  140    140   
        &REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_INDEX_NAME,
  141    141   
        &REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_INDEX_STATUS,
  142    142   
        &REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_PROVISIONED_READ_CAPACITY_UNITS,
  143    143   
        &REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_PROVISIONED_READ_CAPACITY_AUTO_SCALING_SETTINGS,
  144    144   
        &REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_PROVISIONED_WRITE_CAPACITY_UNITS,
  145    145   
        &REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_SETTINGS,
  146    146   
    ],
  147    147   
);
  148    148   
impl ReplicaGlobalSecondaryIndexSettingsDescription {
  149    149   
    /// The schema for this shape.
  150    150   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_SCHEMA;
  151    151   
}
  152    152   
impl ::aws_smithy_schema::serde::SerializableStruct for ReplicaGlobalSecondaryIndexSettingsDescription {
  153    153   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  154    154   
    fn serialize_members(
  155    155   
        &self,
  156    156   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  157    157   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  158    158   
        {
  159    159   
            let val = &self.index_name;
  160    160   
            ser.write_string(&REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_INDEX_NAME, val)?;
  161    161   
        }
  162    162   
        if let Some(ref val) = self.index_status {
  163    163   
            ser.write_string(&REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_INDEX_STATUS, val.as_str())?;
  164    164   
        }
  165    165   
        if let Some(ref val) = self.provisioned_read_capacity_units {
  166    166   
            ser.write_long(
  167    167   
                &REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_PROVISIONED_READ_CAPACITY_UNITS,
  168    168   
                *val,
  169    169   
            )?;
  170    170   
        }
  171    171   
        if let Some(ref val) = self.provisioned_read_capacity_auto_scaling_settings {
  172    172   
            ser.write_struct(
  173    173   
                &REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_PROVISIONED_READ_CAPACITY_AUTO_SCALING_SETTINGS,
  174    174   
                val,
  175    175   
            )?;
  176    176   
        }
  177    177   
        if let Some(ref val) = self.provisioned_write_capacity_units {
  178    178   
            ser.write_long(
  179    179   
                &REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_PROVISIONED_WRITE_CAPACITY_UNITS,
  180    180   
                *val,
  181    181   
            )?;
  182    182   
        }
  183    183   
        if let Some(ref val) = self.provisioned_write_capacity_auto_scaling_settings {
  184    184   
            ser.write_struct(
  185    185   
                &REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_MEMBER_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_SETTINGS,
  186    186   
                val,
  187    187   
            )?;
  188    188   
        }
  189    189   
        Ok(())
  190    190   
    }
  191    191   
}
  192    192   
impl ReplicaGlobalSecondaryIndexSettingsDescription {
  193    193   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  194         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  195         -
        deserializer: &mut D,
         194  +
    pub fn deserialize(
         195  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  196    196   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  197    197   
        #[allow(unused_variables, unused_mut)]
  198    198   
        let mut builder = Self::builder();
  199    199   
        #[allow(
  200    200   
            unused_variables,
  201    201   
            unreachable_code,
  202    202   
            clippy::single_match,
  203    203   
            clippy::match_single_binding,
  204    204   
            clippy::diverging_sub_expression
  205    205   
        )]
  206         -
        deserializer.read_struct(&REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_SCHEMA, (), |_, member, deser| {
         206  +
        deserializer.read_struct(&REPLICAGLOBALSECONDARYINDEXSETTINGSDESCRIPTION_SCHEMA, &mut |member, deser| {
  207    207   
            match member.member_index() {
  208    208   
                Some(0) => {
  209    209   
                    builder.index_name = Some(deser.read_string(member)?);
  210    210   
                }
  211    211   
                Some(1) => {
  212    212   
                    builder.index_status = Some(crate::types::IndexStatus::from(deser.read_string(member)?.as_str()));
  213    213   
                }
  214    214   
                Some(2) => {
  215    215   
                    builder.provisioned_read_capacity_units = Some(deser.read_long(member)?);
  216    216   
                }
  217    217   
                Some(3) => {
  218    218   
                    builder.provisioned_read_capacity_auto_scaling_settings = Some(crate::types::AutoScalingSettingsDescription::deserialize(deser)?);
  219    219   
                }
  220    220   
                Some(4) => {
  221    221   
                    builder.provisioned_write_capacity_units = Some(deser.read_long(member)?);
  222    222   
                }
  223    223   
                Some(5) => {
  224    224   
                    builder.provisioned_write_capacity_auto_scaling_settings =
  225    225   
                        Some(crate::types::AutoScalingSettingsDescription::deserialize(deser)?);
  226    226   
                }
  227    227   
                _ => {}
  228    228   
            }
  229    229   
            Ok(())
  230    230   
        })?;
         231  +
        builder.index_name = builder.index_name.or(Some(String::new()));
  231    232   
        builder
  232    233   
            .build()
  233    234   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  234    235   
    }
  235    236   
}
         237  +
impl ReplicaGlobalSecondaryIndexSettingsDescription {
         238  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         239  +
    pub fn deserialize_with_response(
         240  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         241  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         242  +
        _status: u16,
         243  +
        _body: &[u8],
         244  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         245  +
        Self::deserialize(deserializer)
         246  +
    }
         247  +
}
  236    248   
impl ReplicaGlobalSecondaryIndexSettingsDescription {
  237    249   
    /// Creates a new builder-style object to manufacture [`ReplicaGlobalSecondaryIndexSettingsDescription`](crate::types::ReplicaGlobalSecondaryIndexSettingsDescription).
  238    250   
    pub fn builder() -> crate::types::builders::ReplicaGlobalSecondaryIndexSettingsDescriptionBuilder {
  239    251   
        crate::types::builders::ReplicaGlobalSecondaryIndexSettingsDescriptionBuilder::default()
  240    252   
    }
  241    253   
}
  242    254   
  243    255   
/// A builder for [`ReplicaGlobalSecondaryIndexSettingsDescription`](crate::types::ReplicaGlobalSecondaryIndexSettingsDescription).
  244    256   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  245    257   
#[non_exhaustive]