AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36 (ignoring whitespace)

Files changed:

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

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

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

@@ -69,69 +214,214 @@
   89     89   
    "com.amazonaws.dynamodb",
   90     90   
    "ReplicaSettingsDescription",
   91     91   
);
   92     92   
static REPLICASETTINGSDESCRIPTION_MEMBER_REGION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "com.amazonaws.dynamodb#ReplicaSettingsDescription$RegionName",
   95     95   
        "com.amazonaws.dynamodb",
   96     96   
        "ReplicaSettingsDescription",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "region_name",
          99  +
    "RegionName",
  100    100   
    0,
  101    101   
);
  102    102   
static REPLICASETTINGSDESCRIPTION_MEMBER_REPLICA_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static(
  104    104   
        "com.amazonaws.dynamodb#ReplicaSettingsDescription$ReplicaStatus",
  105    105   
        "com.amazonaws.dynamodb",
  106    106   
        "ReplicaSettingsDescription",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "replica_status",
         109  +
    "ReplicaStatus",
  110    110   
    1,
  111    111   
);
  112    112   
static REPLICASETTINGSDESCRIPTION_MEMBER_REPLICA_BILLING_MODE_SUMMARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.dynamodb#ReplicaSettingsDescription$ReplicaBillingModeSummary",
  115    115   
        "com.amazonaws.dynamodb",
  116    116   
        "ReplicaSettingsDescription",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::Structure,
  119         -
    "replica_billing_mode_summary",
         119  +
    "ReplicaBillingModeSummary",
  120    120   
    2,
  121    121   
);
  122    122   
static REPLICASETTINGSDESCRIPTION_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_UNITS: ::aws_smithy_schema::Schema =
  123    123   
    ::aws_smithy_schema::Schema::new_member(
  124    124   
        ::aws_smithy_schema::ShapeId::from_static(
  125    125   
            "com.amazonaws.dynamodb#ReplicaSettingsDescription$ReplicaProvisionedReadCapacityUnits",
  126    126   
            "com.amazonaws.dynamodb",
  127    127   
            "ReplicaSettingsDescription",
  128    128   
        ),
  129    129   
        ::aws_smithy_schema::ShapeType::Long,
  130         -
        "replica_provisioned_read_capacity_units",
         130  +
        "ReplicaProvisionedReadCapacityUnits",
  131    131   
        3,
  132    132   
    );
  133    133   
static REPLICASETTINGSDESCRIPTION_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_AUTO_SCALING_SETTINGS: ::aws_smithy_schema::Schema =
  134    134   
    ::aws_smithy_schema::Schema::new_member(
  135    135   
        ::aws_smithy_schema::ShapeId::from_static(
  136    136   
            "com.amazonaws.dynamodb#ReplicaSettingsDescription$ReplicaProvisionedReadCapacityAutoScalingSettings",
  137    137   
            "com.amazonaws.dynamodb",
  138    138   
            "ReplicaSettingsDescription",
  139    139   
        ),
  140    140   
        ::aws_smithy_schema::ShapeType::Structure,
  141         -
        "replica_provisioned_read_capacity_auto_scaling_settings",
         141  +
        "ReplicaProvisionedReadCapacityAutoScalingSettings",
  142    142   
        4,
  143    143   
    );
  144    144   
static REPLICASETTINGSDESCRIPTION_MEMBER_REPLICA_PROVISIONED_WRITE_CAPACITY_UNITS: ::aws_smithy_schema::Schema =
  145    145   
    ::aws_smithy_schema::Schema::new_member(
  146    146   
        ::aws_smithy_schema::ShapeId::from_static(
  147    147   
            "com.amazonaws.dynamodb#ReplicaSettingsDescription$ReplicaProvisionedWriteCapacityUnits",
  148    148   
            "com.amazonaws.dynamodb",
  149    149   
            "ReplicaSettingsDescription",
  150    150   
        ),
  151    151   
        ::aws_smithy_schema::ShapeType::Long,
  152         -
        "replica_provisioned_write_capacity_units",
         152  +
        "ReplicaProvisionedWriteCapacityUnits",
  153    153   
        5,
  154    154   
    );
  155    155   
static REPLICASETTINGSDESCRIPTION_MEMBER_REPLICA_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_SETTINGS: ::aws_smithy_schema::Schema =
  156    156   
    ::aws_smithy_schema::Schema::new_member(
  157    157   
        ::aws_smithy_schema::ShapeId::from_static(
  158    158   
            "com.amazonaws.dynamodb#ReplicaSettingsDescription$ReplicaProvisionedWriteCapacityAutoScalingSettings",
  159    159   
            "com.amazonaws.dynamodb",
  160    160   
            "ReplicaSettingsDescription",
  161    161   
        ),
  162    162   
        ::aws_smithy_schema::ShapeType::Structure,
  163         -
        "replica_provisioned_write_capacity_auto_scaling_settings",
         163  +
        "ReplicaProvisionedWriteCapacityAutoScalingSettings",
  164    164   
        6,
  165    165   
    );
  166    166   
static REPLICASETTINGSDESCRIPTION_MEMBER_REPLICA_GLOBAL_SECONDARY_INDEX_SETTINGS: ::aws_smithy_schema::Schema =
  167    167   
    ::aws_smithy_schema::Schema::new_member(
  168    168   
        ::aws_smithy_schema::ShapeId::from_static(
  169    169   
            "com.amazonaws.dynamodb#ReplicaSettingsDescription$ReplicaGlobalSecondaryIndexSettings",
  170    170   
            "com.amazonaws.dynamodb",
  171    171   
            "ReplicaSettingsDescription",
  172    172   
        ),
  173    173   
        ::aws_smithy_schema::ShapeType::List,
  174         -
        "replica_global_secondary_index_settings",
         174  +
        "ReplicaGlobalSecondaryIndexSettings",
  175    175   
        7,
  176    176   
    );
  177    177   
static REPLICASETTINGSDESCRIPTION_MEMBER_REPLICA_TABLE_CLASS_SUMMARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  178    178   
    ::aws_smithy_schema::ShapeId::from_static(
  179    179   
        "com.amazonaws.dynamodb#ReplicaSettingsDescription$ReplicaTableClassSummary",
  180    180   
        "com.amazonaws.dynamodb",
  181    181   
        "ReplicaSettingsDescription",
  182    182   
    ),
  183    183   
    ::aws_smithy_schema::ShapeType::Structure,
  184         -
    "replica_table_class_summary",
         184  +
    "ReplicaTableClassSummary",
  185    185   
    8,
  186    186   
);
  187    187   
static REPLICASETTINGSDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  188    188   
    REPLICASETTINGSDESCRIPTION_SCHEMA_ID,
  189    189   
    ::aws_smithy_schema::ShapeType::Structure,
  190    190   
    &[
  191    191   
        &REPLICASETTINGSDESCRIPTION_MEMBER_REGION_NAME,
  192    192   
        &REPLICASETTINGSDESCRIPTION_MEMBER_REPLICA_STATUS,
  193    193   
        &REPLICASETTINGSDESCRIPTION_MEMBER_REPLICA_BILLING_MODE_SUMMARY,
  194    194   
        &REPLICASETTINGSDESCRIPTION_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_UNITS,
@@ -229,229 +350,359 @@
  249    249   
            )?;
  250    250   
        }
  251    251   
        if let Some(ref val) = self.replica_table_class_summary {
  252    252   
            ser.write_struct(&REPLICASETTINGSDESCRIPTION_MEMBER_REPLICA_TABLE_CLASS_SUMMARY, val)?;
  253    253   
        }
  254    254   
        Ok(())
  255    255   
    }
  256    256   
}
  257    257   
impl ReplicaSettingsDescription {
  258    258   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  259         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  260         -
        deserializer: &mut D,
         259  +
    pub fn deserialize(
         260  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  261    261   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  262    262   
        #[allow(unused_variables, unused_mut)]
  263    263   
        let mut builder = Self::builder();
  264    264   
        #[allow(
  265    265   
            unused_variables,
  266    266   
            unreachable_code,
  267    267   
            clippy::single_match,
  268    268   
            clippy::match_single_binding,
  269    269   
            clippy::diverging_sub_expression
  270    270   
        )]
  271         -
        deserializer.read_struct(&REPLICASETTINGSDESCRIPTION_SCHEMA, (), |_, member, deser| {
         271  +
        deserializer.read_struct(&REPLICASETTINGSDESCRIPTION_SCHEMA, &mut |member, deser| {
  272    272   
            match member.member_index() {
  273    273   
                Some(0) => {
  274    274   
                    builder.region_name = Some(deser.read_string(member)?);
  275    275   
                }
  276    276   
                Some(1) => {
  277    277   
                    builder.replica_status = Some(crate::types::ReplicaStatus::from(deser.read_string(member)?.as_str()));
  278    278   
                }
  279    279   
                Some(2) => {
  280    280   
                    builder.replica_billing_mode_summary = Some(crate::types::BillingModeSummary::deserialize(deser)?);
  281    281   
                }
  282    282   
                Some(3) => {
  283    283   
                    builder.replica_provisioned_read_capacity_units = Some(deser.read_long(member)?);
  284    284   
                }
  285    285   
                Some(4) => {
  286    286   
                    builder.replica_provisioned_read_capacity_auto_scaling_settings =
  287    287   
                        Some(crate::types::AutoScalingSettingsDescription::deserialize(deser)?);
  288    288   
                }
  289    289   
                Some(5) => {
  290    290   
                    builder.replica_provisioned_write_capacity_units = Some(deser.read_long(member)?);
  291    291   
                }
  292    292   
                Some(6) => {
  293    293   
                    builder.replica_provisioned_write_capacity_auto_scaling_settings =
  294    294   
                        Some(crate::types::AutoScalingSettingsDescription::deserialize(deser)?);
  295    295   
                }
  296    296   
                Some(7) => {
  297    297   
                    builder.replica_global_secondary_index_settings = Some({
  298         -
                        let container = if let Some(cap) = deser.container_size() {
  299         -
                            Vec::with_capacity(cap)
  300         -
                        } else {
  301         -
                            Vec::new()
  302         -
                        };
  303         -
                        deser.read_list(member, container, |mut list, deser| {
  304         -
                            list.push(crate::types::ReplicaGlobalSecondaryIndexSettingsDescription::deserialize(deser)?);
  305         -
                            Ok(list)
  306         -
                        })?
         298  +
                        let mut container = Vec::new();
         299  +
                        deser.read_list(member, &mut |deser| {
         300  +
                            container.push(crate::types::ReplicaGlobalSecondaryIndexSettingsDescription::deserialize(deser)?);
         301  +
                            Ok(())
         302  +
                        })?;
         303  +
                        container
  307    304   
                    });
  308    305   
                }
  309    306   
                Some(8) => {
  310    307   
                    builder.replica_table_class_summary = Some(crate::types::TableClassSummary::deserialize(deser)?);
  311    308   
                }
  312    309   
                _ => {}
  313    310   
            }
  314    311   
            Ok(())
  315    312   
        })?;
         313  +
        builder.region_name = builder.region_name.or(Some(String::new()));
  316    314   
        builder
  317    315   
            .build()
  318    316   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  319    317   
    }
  320    318   
}
         319  +
impl ReplicaSettingsDescription {
         320  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         321  +
    pub fn deserialize_with_response(
         322  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         323  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         324  +
        _status: u16,
         325  +
        _body: &[u8],
         326  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         327  +
        Self::deserialize(deserializer)
         328  +
    }
         329  +
}
  321    330   
impl ReplicaSettingsDescription {
  322    331   
    /// Creates a new builder-style object to manufacture [`ReplicaSettingsDescription`](crate::types::ReplicaSettingsDescription).
  323    332   
    pub fn builder() -> crate::types::builders::ReplicaSettingsDescriptionBuilder {
  324    333   
        crate::types::builders::ReplicaSettingsDescriptionBuilder::default()
  325    334   
    }
  326    335   
}
  327    336   
  328    337   
/// A builder for [`ReplicaSettingsDescription`](crate::types::ReplicaSettingsDescription).
  329    338   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  330    339   
#[non_exhaustive]

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

@@ -26,26 +232,241 @@
   46     46   
    "com.amazonaws.dynamodb",
   47     47   
    "ReplicaSettingsUpdate",
   48     48   
);
   49     49   
static REPLICASETTINGSUPDATE_MEMBER_REGION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static(
   51     51   
        "com.amazonaws.dynamodb#ReplicaSettingsUpdate$RegionName",
   52     52   
        "com.amazonaws.dynamodb",
   53     53   
        "ReplicaSettingsUpdate",
   54     54   
    ),
   55     55   
    ::aws_smithy_schema::ShapeType::String,
   56         -
    "region_name",
          56  +
    "RegionName",
   57     57   
    0,
   58     58   
);
   59     59   
static REPLICASETTINGSUPDATE_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_UNITS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.dynamodb#ReplicaSettingsUpdate$ReplicaProvisionedReadCapacityUnits",
   62     62   
        "com.amazonaws.dynamodb",
   63     63   
        "ReplicaSettingsUpdate",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::Long,
   66         -
    "replica_provisioned_read_capacity_units",
          66  +
    "ReplicaProvisionedReadCapacityUnits",
   67     67   
    1,
   68     68   
);
   69     69   
static REPLICASETTINGSUPDATE_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_AUTO_SCALING_SETTINGS_UPDATE: ::aws_smithy_schema::Schema =
   70     70   
    ::aws_smithy_schema::Schema::new_member(
   71     71   
        ::aws_smithy_schema::ShapeId::from_static(
   72     72   
            "com.amazonaws.dynamodb#ReplicaSettingsUpdate$ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate",
   73     73   
            "com.amazonaws.dynamodb",
   74     74   
            "ReplicaSettingsUpdate",
   75     75   
        ),
   76     76   
        ::aws_smithy_schema::ShapeType::Structure,
   77         -
        "replica_provisioned_read_capacity_auto_scaling_settings_update",
          77  +
        "ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate",
   78     78   
        2,
   79     79   
    );
   80     80   
static REPLICASETTINGSUPDATE_MEMBER_REPLICA_GLOBAL_SECONDARY_INDEX_SETTINGS_UPDATE: ::aws_smithy_schema::Schema =
   81     81   
    ::aws_smithy_schema::Schema::new_member(
   82     82   
        ::aws_smithy_schema::ShapeId::from_static(
   83     83   
            "com.amazonaws.dynamodb#ReplicaSettingsUpdate$ReplicaGlobalSecondaryIndexSettingsUpdate",
   84     84   
            "com.amazonaws.dynamodb",
   85     85   
            "ReplicaSettingsUpdate",
   86     86   
        ),
   87     87   
        ::aws_smithy_schema::ShapeType::List,
   88         -
        "replica_global_secondary_index_settings_update",
          88  +
        "ReplicaGlobalSecondaryIndexSettingsUpdate",
   89     89   
        3,
   90     90   
    );
   91     91   
static REPLICASETTINGSUPDATE_MEMBER_REPLICA_TABLE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.dynamodb#ReplicaSettingsUpdate$ReplicaTableClass",
   94     94   
        "com.amazonaws.dynamodb",
   95     95   
        "ReplicaSettingsUpdate",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::String,
   98         -
    "replica_table_class",
          98  +
    "ReplicaTableClass",
   99     99   
    4,
  100    100   
);
  101    101   
static REPLICASETTINGSUPDATE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  102    102   
    REPLICASETTINGSUPDATE_SCHEMA_ID,
  103    103   
    ::aws_smithy_schema::ShapeType::Structure,
  104    104   
    &[
  105    105   
        &REPLICASETTINGSUPDATE_MEMBER_REGION_NAME,
  106    106   
        &REPLICASETTINGSUPDATE_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_UNITS,
  107    107   
        &REPLICASETTINGSUPDATE_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_AUTO_SCALING_SETTINGS_UPDATE,
  108    108   
        &REPLICASETTINGSUPDATE_MEMBER_REPLICA_GLOBAL_SECONDARY_INDEX_SETTINGS_UPDATE,
  109    109   
        &REPLICASETTINGSUPDATE_MEMBER_REPLICA_TABLE_CLASS,
  110    110   
    ],
  111    111   
);
  112    112   
impl ReplicaSettingsUpdate {
  113    113   
    /// The schema for this shape.
  114    114   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REPLICASETTINGSUPDATE_SCHEMA;
  115    115   
}
  116    116   
impl ::aws_smithy_schema::serde::SerializableStruct for ReplicaSettingsUpdate {
  117    117   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  118    118   
    fn serialize_members(
  119    119   
        &self,
  120    120   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  121    121   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  122    122   
        {
  123    123   
            let val = &self.region_name;
  124    124   
            ser.write_string(&REPLICASETTINGSUPDATE_MEMBER_REGION_NAME, val)?;
  125    125   
        }
  126    126   
        if let Some(ref val) = self.replica_provisioned_read_capacity_units {
  127    127   
            ser.write_long(&REPLICASETTINGSUPDATE_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_UNITS, *val)?;
  128    128   
        }
  129    129   
        if let Some(ref val) = self.replica_provisioned_read_capacity_auto_scaling_settings_update {
  130    130   
            ser.write_struct(
  131    131   
                &REPLICASETTINGSUPDATE_MEMBER_REPLICA_PROVISIONED_READ_CAPACITY_AUTO_SCALING_SETTINGS_UPDATE,
  132    132   
                val,
  133    133   
            )?;
  134    134   
        }
  135    135   
        if let Some(ref val) = self.replica_global_secondary_index_settings_update {
  136    136   
            ser.write_list(
  137    137   
                &REPLICASETTINGSUPDATE_MEMBER_REPLICA_GLOBAL_SECONDARY_INDEX_SETTINGS_UPDATE,
  138    138   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  139    139   
                    for item in val {
  140    140   
                        ser.write_struct(crate::types::ReplicaGlobalSecondaryIndexSettingsUpdate::SCHEMA, item)?;
  141    141   
                    }
  142    142   
                    Ok(())
  143    143   
                },
  144    144   
            )?;
  145    145   
        }
  146    146   
        if let Some(ref val) = self.replica_table_class {
  147    147   
            ser.write_string(&REPLICASETTINGSUPDATE_MEMBER_REPLICA_TABLE_CLASS, val.as_str())?;
  148    148   
        }
  149    149   
        Ok(())
  150    150   
    }
  151    151   
}
  152    152   
impl ReplicaSettingsUpdate {
  153    153   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  154         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  155         -
        deserializer: &mut D,
         154  +
    pub fn deserialize(
         155  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  156    156   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  157    157   
        #[allow(unused_variables, unused_mut)]
  158    158   
        let mut builder = Self::builder();
  159    159   
        #[allow(
  160    160   
            unused_variables,
  161    161   
            unreachable_code,
  162    162   
            clippy::single_match,
  163    163   
            clippy::match_single_binding,
  164    164   
            clippy::diverging_sub_expression
  165    165   
        )]
  166         -
        deserializer.read_struct(&REPLICASETTINGSUPDATE_SCHEMA, (), |_, member, deser| {
         166  +
        deserializer.read_struct(&REPLICASETTINGSUPDATE_SCHEMA, &mut |member, deser| {
  167    167   
            match member.member_index() {
  168    168   
                Some(0) => {
  169    169   
                    builder.region_name = Some(deser.read_string(member)?);
  170    170   
                }
  171    171   
                Some(1) => {
  172    172   
                    builder.replica_provisioned_read_capacity_units = Some(deser.read_long(member)?);
  173    173   
                }
  174    174   
                Some(2) => {
  175    175   
                    builder.replica_provisioned_read_capacity_auto_scaling_settings_update =
  176    176   
                        Some(crate::types::AutoScalingSettingsUpdate::deserialize(deser)?);
  177    177   
                }
  178    178   
                Some(3) => {
  179    179   
                    builder.replica_global_secondary_index_settings_update = Some({
  180         -
                        let container = if let Some(cap) = deser.container_size() {
  181         -
                            Vec::with_capacity(cap)
  182         -
                        } else {
  183         -
                            Vec::new()
  184         -
                        };
  185         -
                        deser.read_list(member, container, |mut list, deser| {
  186         -
                            list.push(crate::types::ReplicaGlobalSecondaryIndexSettingsUpdate::deserialize(deser)?);
  187         -
                            Ok(list)
  188         -
                        })?
         180  +
                        let mut container = Vec::new();
         181  +
                        deser.read_list(member, &mut |deser| {
         182  +
                            container.push(crate::types::ReplicaGlobalSecondaryIndexSettingsUpdate::deserialize(deser)?);
         183  +
                            Ok(())
         184  +
                        })?;
         185  +
                        container
  189    186   
                    });
  190    187   
                }
  191    188   
                Some(4) => {
  192    189   
                    builder.replica_table_class = Some(crate::types::TableClass::from(deser.read_string(member)?.as_str()));
  193    190   
                }
  194    191   
                _ => {}
  195    192   
            }
  196    193   
            Ok(())
  197    194   
        })?;
         195  +
        builder.region_name = builder.region_name.or(Some(String::new()));
  198    196   
        builder
  199    197   
            .build()
  200    198   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  201    199   
    }
  202    200   
}
         201  +
impl ReplicaSettingsUpdate {
         202  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         203  +
    pub fn deserialize_with_response(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         205  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         206  +
        _status: u16,
         207  +
        _body: &[u8],
         208  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         209  +
        Self::deserialize(deserializer)
         210  +
    }
         211  +
}
  203    212   
impl ReplicaSettingsUpdate {
  204    213   
    /// Creates a new builder-style object to manufacture [`ReplicaSettingsUpdate`](crate::types::ReplicaSettingsUpdate).
  205    214   
    pub fn builder() -> crate::types::builders::ReplicaSettingsUpdateBuilder {
  206    215   
        crate::types::builders::ReplicaSettingsUpdateBuilder::default()
  207    216   
    }
  208    217   
}
  209    218   
  210    219   
/// A builder for [`ReplicaSettingsUpdate`](crate::types::ReplicaSettingsUpdate).
  211    220   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  212    221   
#[non_exhaustive]

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

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

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

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

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

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

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

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

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

@@ -67,67 +217,217 @@
   87     87   
    "com.amazonaws.dynamodb",
   88     88   
    "SourceTableDetails",
   89     89   
);
   90     90   
static SOURCETABLEDETAILS_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.dynamodb#SourceTableDetails$TableName",
   93     93   
        "com.amazonaws.dynamodb",
   94     94   
        "SourceTableDetails",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::String,
   97         -
    "table_name",
          97  +
    "TableName",
   98     98   
    0,
   99     99   
);
  100    100   
static SOURCETABLEDETAILS_MEMBER_TABLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.dynamodb#SourceTableDetails$TableId",
  103    103   
        "com.amazonaws.dynamodb",
  104    104   
        "SourceTableDetails",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::String,
  107         -
    "table_id",
         107  +
    "TableId",
  108    108   
    1,
  109    109   
);
  110    110   
static SOURCETABLEDETAILS_MEMBER_TABLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static(
  112    112   
        "com.amazonaws.dynamodb#SourceTableDetails$TableArn",
  113    113   
        "com.amazonaws.dynamodb",
  114    114   
        "SourceTableDetails",
  115    115   
    ),
  116    116   
    ::aws_smithy_schema::ShapeType::String,
  117         -
    "table_arn",
         117  +
    "TableArn",
  118    118   
    2,
  119    119   
);
  120    120   
static SOURCETABLEDETAILS_MEMBER_TABLE_SIZE_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  121    121   
    ::aws_smithy_schema::ShapeId::from_static(
  122    122   
        "com.amazonaws.dynamodb#SourceTableDetails$TableSizeBytes",
  123    123   
        "com.amazonaws.dynamodb",
  124    124   
        "SourceTableDetails",
  125    125   
    ),
  126    126   
    ::aws_smithy_schema::ShapeType::Long,
  127         -
    "table_size_bytes",
         127  +
    "TableSizeBytes",
  128    128   
    3,
  129    129   
);
  130    130   
static SOURCETABLEDETAILS_MEMBER_KEY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static(
  132    132   
        "com.amazonaws.dynamodb#SourceTableDetails$KeySchema",
  133    133   
        "com.amazonaws.dynamodb",
  134    134   
        "SourceTableDetails",
  135    135   
    ),
  136    136   
    ::aws_smithy_schema::ShapeType::List,
  137         -
    "key_schema",
         137  +
    "KeySchema",
  138    138   
    4,
  139    139   
);
  140    140   
static SOURCETABLEDETAILS_MEMBER_TABLE_CREATION_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static(
  142    142   
        "com.amazonaws.dynamodb#SourceTableDetails$TableCreationDateTime",
  143    143   
        "com.amazonaws.dynamodb",
  144    144   
        "SourceTableDetails",
  145    145   
    ),
  146    146   
    ::aws_smithy_schema::ShapeType::Timestamp,
  147         -
    "table_creation_date_time",
         147  +
    "TableCreationDateTime",
  148    148   
    5,
  149    149   
);
  150    150   
static SOURCETABLEDETAILS_MEMBER_PROVISIONED_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  151    151   
    ::aws_smithy_schema::ShapeId::from_static(
  152    152   
        "com.amazonaws.dynamodb#SourceTableDetails$ProvisionedThroughput",
  153    153   
        "com.amazonaws.dynamodb",
  154    154   
        "SourceTableDetails",
  155    155   
    ),
  156    156   
    ::aws_smithy_schema::ShapeType::Structure,
  157         -
    "provisioned_throughput",
         157  +
    "ProvisionedThroughput",
  158    158   
    6,
  159    159   
);
  160    160   
static SOURCETABLEDETAILS_MEMBER_ON_DEMAND_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  161    161   
    ::aws_smithy_schema::ShapeId::from_static(
  162    162   
        "com.amazonaws.dynamodb#SourceTableDetails$OnDemandThroughput",
  163    163   
        "com.amazonaws.dynamodb",
  164    164   
        "SourceTableDetails",
  165    165   
    ),
  166    166   
    ::aws_smithy_schema::ShapeType::Structure,
  167         -
    "on_demand_throughput",
         167  +
    "OnDemandThroughput",
  168    168   
    7,
  169    169   
);
  170    170   
static SOURCETABLEDETAILS_MEMBER_ITEM_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  171    171   
    ::aws_smithy_schema::ShapeId::from_static(
  172    172   
        "com.amazonaws.dynamodb#SourceTableDetails$ItemCount",
  173    173   
        "com.amazonaws.dynamodb",
  174    174   
        "SourceTableDetails",
  175    175   
    ),
  176    176   
    ::aws_smithy_schema::ShapeType::Long,
  177         -
    "item_count",
         177  +
    "ItemCount",
  178    178   
    8,
  179    179   
);
  180    180   
static SOURCETABLEDETAILS_MEMBER_BILLING_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  181    181   
    ::aws_smithy_schema::ShapeId::from_static(
  182    182   
        "com.amazonaws.dynamodb#SourceTableDetails$BillingMode",
  183    183   
        "com.amazonaws.dynamodb",
  184    184   
        "SourceTableDetails",
  185    185   
    ),
  186    186   
    ::aws_smithy_schema::ShapeType::String,
  187         -
    "billing_mode",
         187  +
    "BillingMode",
  188    188   
    9,
  189    189   
);
  190    190   
static SOURCETABLEDETAILS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  191    191   
    SOURCETABLEDETAILS_SCHEMA_ID,
  192    192   
    ::aws_smithy_schema::ShapeType::Structure,
  193    193   
    &[
  194    194   
        &SOURCETABLEDETAILS_MEMBER_TABLE_NAME,
  195    195   
        &SOURCETABLEDETAILS_MEMBER_TABLE_ID,
  196    196   
        &SOURCETABLEDETAILS_MEMBER_TABLE_ARN,
  197    197   
        &SOURCETABLEDETAILS_MEMBER_TABLE_SIZE_BYTES,
@@ -234,234 +356,368 @@
  254    254   
            ser.write_long(&SOURCETABLEDETAILS_MEMBER_ITEM_COUNT, *val)?;
  255    255   
        }
  256    256   
        if let Some(ref val) = self.billing_mode {
  257    257   
            ser.write_string(&SOURCETABLEDETAILS_MEMBER_BILLING_MODE, val.as_str())?;
  258    258   
        }
  259    259   
        Ok(())
  260    260   
    }
  261    261   
}
  262    262   
impl SourceTableDetails {
  263    263   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  264         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  265         -
        deserializer: &mut D,
         264  +
    pub fn deserialize(
         265  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  266    266   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  267    267   
        #[allow(unused_variables, unused_mut)]
  268    268   
        let mut builder = Self::builder();
  269    269   
        #[allow(
  270    270   
            unused_variables,
  271    271   
            unreachable_code,
  272    272   
            clippy::single_match,
  273    273   
            clippy::match_single_binding,
  274    274   
            clippy::diverging_sub_expression
  275    275   
        )]
  276         -
        deserializer.read_struct(&SOURCETABLEDETAILS_SCHEMA, (), |_, member, deser| {
         276  +
        deserializer.read_struct(&SOURCETABLEDETAILS_SCHEMA, &mut |member, deser| {
  277    277   
            match member.member_index() {
  278    278   
                Some(0) => {
  279    279   
                    builder.table_name = Some(deser.read_string(member)?);
  280    280   
                }
  281    281   
                Some(1) => {
  282    282   
                    builder.table_id = Some(deser.read_string(member)?);
  283    283   
                }
  284    284   
                Some(2) => {
  285    285   
                    builder.table_arn = Some(deser.read_string(member)?);
  286    286   
                }
  287    287   
                Some(3) => {
  288    288   
                    builder.table_size_bytes = Some(deser.read_long(member)?);
  289    289   
                }
  290    290   
                Some(4) => {
  291    291   
                    builder.key_schema = Some({
  292         -
                        let container = if let Some(cap) = deser.container_size() {
  293         -
                            Vec::with_capacity(cap)
  294         -
                        } else {
  295         -
                            Vec::new()
  296         -
                        };
  297         -
                        deser.read_list(member, container, |mut list, deser| {
  298         -
                            list.push(crate::types::KeySchemaElement::deserialize(deser)?);
  299         -
                            Ok(list)
  300         -
                        })?
         292  +
                        let mut container = Vec::new();
         293  +
                        deser.read_list(member, &mut |deser| {
         294  +
                            container.push(crate::types::KeySchemaElement::deserialize(deser)?);
         295  +
                            Ok(())
         296  +
                        })?;
         297  +
                        container
  301    298   
                    });
  302    299   
                }
  303    300   
                Some(5) => {
  304    301   
                    builder.table_creation_date_time = Some(deser.read_timestamp(member)?);
  305    302   
                }
  306    303   
                Some(6) => {
  307    304   
                    builder.provisioned_throughput = Some(crate::types::ProvisionedThroughput::deserialize(deser)?);
  308    305   
                }
  309    306   
                Some(7) => {
  310    307   
                    builder.on_demand_throughput = Some(crate::types::OnDemandThroughput::deserialize(deser)?);
  311    308   
                }
  312    309   
                Some(8) => {
  313    310   
                    builder.item_count = Some(deser.read_long(member)?);
  314    311   
                }
  315    312   
                Some(9) => {
  316    313   
                    builder.billing_mode = Some(crate::types::BillingMode::from(deser.read_string(member)?.as_str()));
  317    314   
                }
  318    315   
                _ => {}
  319    316   
            }
  320    317   
            Ok(())
  321    318   
        })?;
         319  +
        builder.table_name = builder.table_name.or(Some(String::new()));
         320  +
        builder.table_id = builder.table_id.or(Some(String::new()));
         321  +
        builder.key_schema = builder.key_schema.or(Some(Vec::new()));
         322  +
        builder.table_creation_date_time = builder.table_creation_date_time.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
  322    323   
        builder
  323    324   
            .build()
  324    325   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  325    326   
    }
  326    327   
}
         328  +
impl SourceTableDetails {
         329  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         330  +
    pub fn deserialize_with_response(
         331  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         332  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         333  +
        _status: u16,
         334  +
        _body: &[u8],
         335  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         336  +
        Self::deserialize(deserializer)
         337  +
    }
         338  +
}
  327    339   
impl SourceTableDetails {
  328    340   
    /// Creates a new builder-style object to manufacture [`SourceTableDetails`](crate::types::SourceTableDetails).
  329    341   
    pub fn builder() -> crate::types::builders::SourceTableDetailsBuilder {
  330    342   
        crate::types::builders::SourceTableDetailsBuilder::default()
  331    343   
    }
  332    344   
}
  333    345   
  334    346   
/// A builder for [`SourceTableDetails`](crate::types::SourceTableDetails).
  335    347   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  336    348   
#[non_exhaustive]

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

@@ -26,26 +241,246 @@
   46     46   
    "com.amazonaws.dynamodb",
   47     47   
    "SourceTableFeatureDetails",
   48     48   
);
   49     49   
static SOURCETABLEFEATUREDETAILS_MEMBER_LOCAL_SECONDARY_INDEXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static(
   51     51   
        "com.amazonaws.dynamodb#SourceTableFeatureDetails$LocalSecondaryIndexes",
   52     52   
        "com.amazonaws.dynamodb",
   53     53   
        "SourceTableFeatureDetails",
   54     54   
    ),
   55     55   
    ::aws_smithy_schema::ShapeType::List,
   56         -
    "local_secondary_indexes",
          56  +
    "LocalSecondaryIndexes",
   57     57   
    0,
   58     58   
);
   59     59   
static SOURCETABLEFEATUREDETAILS_MEMBER_GLOBAL_SECONDARY_INDEXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.dynamodb#SourceTableFeatureDetails$GlobalSecondaryIndexes",
   62     62   
        "com.amazonaws.dynamodb",
   63     63   
        "SourceTableFeatureDetails",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::List,
   66         -
    "global_secondary_indexes",
          66  +
    "GlobalSecondaryIndexes",
   67     67   
    1,
   68     68   
);
   69     69   
static SOURCETABLEFEATUREDETAILS_MEMBER_STREAM_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.dynamodb#SourceTableFeatureDetails$StreamDescription",
   72     72   
        "com.amazonaws.dynamodb",
   73     73   
        "SourceTableFeatureDetails",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::Structure,
   76         -
    "stream_description",
          76  +
    "StreamDescription",
   77     77   
    2,
   78     78   
);
   79     79   
static SOURCETABLEFEATUREDETAILS_MEMBER_TIME_TO_LIVE_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.dynamodb#SourceTableFeatureDetails$TimeToLiveDescription",
   82     82   
        "com.amazonaws.dynamodb",
   83     83   
        "SourceTableFeatureDetails",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86         -
    "time_to_live_description",
          86  +
    "TimeToLiveDescription",
   87     87   
    3,
   88     88   
);
   89     89   
static SOURCETABLEFEATUREDETAILS_MEMBER_SSE_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.dynamodb#SourceTableFeatureDetails$SSEDescription",
   92     92   
        "com.amazonaws.dynamodb",
   93     93   
        "SourceTableFeatureDetails",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::Structure,
   96         -
    "sse_description",
          96  +
    "SSEDescription",
   97     97   
    4,
   98     98   
);
   99     99   
static SOURCETABLEFEATUREDETAILS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  100    100   
    SOURCETABLEFEATUREDETAILS_SCHEMA_ID,
  101    101   
    ::aws_smithy_schema::ShapeType::Structure,
  102    102   
    &[
  103    103   
        &SOURCETABLEFEATUREDETAILS_MEMBER_LOCAL_SECONDARY_INDEXES,
  104    104   
        &SOURCETABLEFEATUREDETAILS_MEMBER_GLOBAL_SECONDARY_INDEXES,
  105    105   
        &SOURCETABLEFEATUREDETAILS_MEMBER_STREAM_DESCRIPTION,
  106    106   
        &SOURCETABLEFEATUREDETAILS_MEMBER_TIME_TO_LIVE_DESCRIPTION,
  107    107   
        &SOURCETABLEFEATUREDETAILS_MEMBER_SSE_DESCRIPTION,
  108    108   
    ],
  109    109   
);
  110    110   
impl SourceTableFeatureDetails {
  111    111   
    /// The schema for this shape.
  112    112   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SOURCETABLEFEATUREDETAILS_SCHEMA;
  113    113   
}
  114    114   
impl ::aws_smithy_schema::serde::SerializableStruct for SourceTableFeatureDetails {
  115    115   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  116    116   
    fn serialize_members(
  117    117   
        &self,
  118    118   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  119    119   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  120    120   
        if let Some(ref val) = self.local_secondary_indexes {
  121    121   
            ser.write_list(
  122    122   
                &SOURCETABLEFEATUREDETAILS_MEMBER_LOCAL_SECONDARY_INDEXES,
  123    123   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  124    124   
                    for item in val {
  125    125   
                        ser.write_struct(crate::types::LocalSecondaryIndexInfo::SCHEMA, item)?;
  126    126   
                    }
  127    127   
                    Ok(())
  128    128   
                },
  129    129   
            )?;
  130    130   
        }
  131    131   
        if let Some(ref val) = self.global_secondary_indexes {
  132    132   
            ser.write_list(
  133    133   
                &SOURCETABLEFEATUREDETAILS_MEMBER_GLOBAL_SECONDARY_INDEXES,
  134    134   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  135    135   
                    for item in val {
  136    136   
                        ser.write_struct(crate::types::GlobalSecondaryIndexInfo::SCHEMA, item)?;
  137    137   
                    }
  138    138   
                    Ok(())
  139    139   
                },
  140    140   
            )?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.stream_description {
  143    143   
            ser.write_struct(&SOURCETABLEFEATUREDETAILS_MEMBER_STREAM_DESCRIPTION, val)?;
  144    144   
        }
  145    145   
        if let Some(ref val) = self.time_to_live_description {
  146    146   
            ser.write_struct(&SOURCETABLEFEATUREDETAILS_MEMBER_TIME_TO_LIVE_DESCRIPTION, val)?;
  147    147   
        }
  148    148   
        if let Some(ref val) = self.sse_description {
  149    149   
            ser.write_struct(&SOURCETABLEFEATUREDETAILS_MEMBER_SSE_DESCRIPTION, val)?;
  150    150   
        }
  151    151   
        Ok(())
  152    152   
    }
  153    153   
}
  154    154   
impl SourceTableFeatureDetails {
  155    155   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  156         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  157         -
        deserializer: &mut D,
         156  +
    pub fn deserialize(
         157  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  158    158   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  159    159   
        #[allow(unused_variables, unused_mut)]
  160    160   
        let mut builder = Self::builder();
  161    161   
        #[allow(
  162    162   
            unused_variables,
  163    163   
            unreachable_code,
  164    164   
            clippy::single_match,
  165    165   
            clippy::match_single_binding,
  166    166   
            clippy::diverging_sub_expression
  167    167   
        )]
  168         -
        deserializer.read_struct(&SOURCETABLEFEATUREDETAILS_SCHEMA, (), |_, member, deser| {
         168  +
        deserializer.read_struct(&SOURCETABLEFEATUREDETAILS_SCHEMA, &mut |member, deser| {
  169    169   
            match member.member_index() {
  170    170   
                Some(0) => {
  171    171   
                    builder.local_secondary_indexes = Some({
  172         -
                        let container = if let Some(cap) = deser.container_size() {
  173         -
                            Vec::with_capacity(cap)
  174         -
                        } else {
  175         -
                            Vec::new()
  176         -
                        };
  177         -
                        deser.read_list(member, container, |mut list, deser| {
  178         -
                            list.push(crate::types::LocalSecondaryIndexInfo::deserialize(deser)?);
  179         -
                            Ok(list)
  180         -
                        })?
         172  +
                        let mut container = Vec::new();
         173  +
                        deser.read_list(member, &mut |deser| {
         174  +
                            container.push(crate::types::LocalSecondaryIndexInfo::deserialize(deser)?);
         175  +
                            Ok(())
         176  +
                        })?;
         177  +
                        container
  181    178   
                    });
  182    179   
                }
  183    180   
                Some(1) => {
  184    181   
                    builder.global_secondary_indexes = Some({
  185         -
                        let container = if let Some(cap) = deser.container_size() {
  186         -
                            Vec::with_capacity(cap)
  187         -
                        } else {
  188         -
                            Vec::new()
  189         -
                        };
  190         -
                        deser.read_list(member, container, |mut list, deser| {
  191         -
                            list.push(crate::types::GlobalSecondaryIndexInfo::deserialize(deser)?);
  192         -
                            Ok(list)
  193         -
                        })?
         182  +
                        let mut container = Vec::new();
         183  +
                        deser.read_list(member, &mut |deser| {
         184  +
                            container.push(crate::types::GlobalSecondaryIndexInfo::deserialize(deser)?);
         185  +
                            Ok(())
         186  +
                        })?;
         187  +
                        container
  194    188   
                    });
  195    189   
                }
  196    190   
                Some(2) => {
  197    191   
                    builder.stream_description = Some(crate::types::StreamSpecification::deserialize(deser)?);
  198    192   
                }
  199    193   
                Some(3) => {
  200    194   
                    builder.time_to_live_description = Some(crate::types::TimeToLiveDescription::deserialize(deser)?);
  201    195   
                }
  202    196   
                Some(4) => {
  203    197   
                    builder.sse_description = Some(crate::types::SseDescription::deserialize(deser)?);
  204    198   
                }
  205    199   
                _ => {}
  206    200   
            }
  207    201   
            Ok(())
  208    202   
        })?;
  209    203   
        Ok(builder.build())
  210    204   
    }
  211    205   
}
         206  +
impl SourceTableFeatureDetails {
         207  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         208  +
    pub fn deserialize_with_response(
         209  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         210  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         211  +
        _status: u16,
         212  +
        _body: &[u8],
         213  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         214  +
        Self::deserialize(deserializer)
         215  +
    }
         216  +
}
  212    217   
impl SourceTableFeatureDetails {
  213    218   
    /// Creates a new builder-style object to manufacture [`SourceTableFeatureDetails`](crate::types::SourceTableFeatureDetails).
  214    219   
    pub fn builder() -> crate::types::builders::SourceTableFeatureDetailsBuilder {
  215    220   
        crate::types::builders::SourceTableFeatureDetailsBuilder::default()
  216    221   
    }
  217    222   
}
  218    223   
  219    224   
/// A builder for [`SourceTableFeatureDetails`](crate::types::SourceTableFeatureDetails).
  220    225   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  221    226   
#[non_exhaustive]

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

@@ -29,29 +191,202 @@
   49     49   
    /// <p>Indicates the time, in UNIX epoch date format, when DynamoDB detected that the table's KMS key was inaccessible. This attribute will automatically be cleared when DynamoDB detects that the table's KMS key is accessible again. DynamoDB will initiate the table archival process when table's KMS key remains inaccessible for more than seven days from this date.</p>
   50     50   
    pub fn inaccessible_encryption_date_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
   51     51   
        self.inaccessible_encryption_date_time.as_ref()
   52     52   
    }
   53     53   
}
   54     54   
static SSEDESCRIPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#SSEDescription", "com.amazonaws.dynamodb", "SSEDescription");
   56     56   
static SSEDESCRIPTION_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#SSEDescription$Status", "com.amazonaws.dynamodb", "SSEDescription"),
   58     58   
    ::aws_smithy_schema::ShapeType::String,
   59         -
    "status",
          59  +
    "Status",
   60     60   
    0,
   61     61   
);
   62     62   
static SSEDESCRIPTION_MEMBER_SSE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.dynamodb#SSEDescription$SSEType",
   65     65   
        "com.amazonaws.dynamodb",
   66     66   
        "SSEDescription",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "sse_type",
          69  +
    "SSEType",
   70     70   
    1,
   71     71   
);
   72     72   
static SSEDESCRIPTION_MEMBER_KMS_MASTER_KEY_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.dynamodb#SSEDescription$KMSMasterKeyArn",
   75     75   
        "com.amazonaws.dynamodb",
   76     76   
        "SSEDescription",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "kms_master_key_arn",
          79  +
    "KMSMasterKeyArn",
   80     80   
    2,
   81     81   
);
   82     82   
static SSEDESCRIPTION_MEMBER_INACCESSIBLE_ENCRYPTION_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.dynamodb#SSEDescription$InaccessibleEncryptionDateTime",
   85     85   
        "com.amazonaws.dynamodb",
   86     86   
        "SSEDescription",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::Timestamp,
   89         -
    "inaccessible_encryption_date_time",
          89  +
    "InaccessibleEncryptionDateTime",
   90     90   
    3,
   91     91   
);
   92     92   
static SSEDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   93     93   
    SSEDESCRIPTION_SCHEMA_ID,
   94     94   
    ::aws_smithy_schema::ShapeType::Structure,
   95     95   
    &[
   96     96   
        &SSEDESCRIPTION_MEMBER_STATUS,
   97     97   
        &SSEDESCRIPTION_MEMBER_SSE_TYPE,
   98     98   
        &SSEDESCRIPTION_MEMBER_KMS_MASTER_KEY_ARN,
   99     99   
        &SSEDESCRIPTION_MEMBER_INACCESSIBLE_ENCRYPTION_DATE_TIME,
  100    100   
    ],
  101    101   
);
  102    102   
impl SseDescription {
  103    103   
    /// The schema for this shape.
  104    104   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SSEDESCRIPTION_SCHEMA;
  105    105   
}
  106    106   
impl ::aws_smithy_schema::serde::SerializableStruct for SseDescription {
  107    107   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  108    108   
    fn serialize_members(
  109    109   
        &self,
  110    110   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  111    111   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  112    112   
        if let Some(ref val) = self.status {
  113    113   
            ser.write_string(&SSEDESCRIPTION_MEMBER_STATUS, val.as_str())?;
  114    114   
        }
  115    115   
        if let Some(ref val) = self.sse_type {
  116    116   
            ser.write_string(&SSEDESCRIPTION_MEMBER_SSE_TYPE, val.as_str())?;
  117    117   
        }
  118    118   
        if let Some(ref val) = self.kms_master_key_arn {
  119    119   
            ser.write_string(&SSEDESCRIPTION_MEMBER_KMS_MASTER_KEY_ARN, val)?;
  120    120   
        }
  121    121   
        if let Some(ref val) = self.inaccessible_encryption_date_time {
  122    122   
            ser.write_timestamp(&SSEDESCRIPTION_MEMBER_INACCESSIBLE_ENCRYPTION_DATE_TIME, val)?;
  123    123   
        }
  124    124   
        Ok(())
  125    125   
    }
  126    126   
}
  127    127   
impl SseDescription {
  128    128   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  129         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  130         -
        deserializer: &mut D,
         129  +
    pub fn deserialize(
         130  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  131    131   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  132    132   
        #[allow(unused_variables, unused_mut)]
  133    133   
        let mut builder = Self::builder();
  134    134   
        #[allow(
  135    135   
            unused_variables,
  136    136   
            unreachable_code,
  137    137   
            clippy::single_match,
  138    138   
            clippy::match_single_binding,
  139    139   
            clippy::diverging_sub_expression
  140    140   
        )]
  141         -
        deserializer.read_struct(&SSEDESCRIPTION_SCHEMA, (), |_, member, deser| {
         141  +
        deserializer.read_struct(&SSEDESCRIPTION_SCHEMA, &mut |member, deser| {
  142    142   
            match member.member_index() {
  143    143   
                Some(0) => {
  144    144   
                    builder.status = Some(crate::types::SseStatus::from(deser.read_string(member)?.as_str()));
  145    145   
                }
  146    146   
                Some(1) => {
  147    147   
                    builder.sse_type = Some(crate::types::SseType::from(deser.read_string(member)?.as_str()));
  148    148   
                }
  149    149   
                Some(2) => {
  150    150   
                    builder.kms_master_key_arn = Some(deser.read_string(member)?);
  151    151   
                }
  152    152   
                Some(3) => {
  153    153   
                    builder.inaccessible_encryption_date_time = Some(deser.read_timestamp(member)?);
  154    154   
                }
  155    155   
                _ => {}
  156    156   
            }
  157    157   
            Ok(())
  158    158   
        })?;
  159    159   
        Ok(builder.build())
  160    160   
    }
  161    161   
}
         162  +
impl SseDescription {
         163  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         164  +
    pub fn deserialize_with_response(
         165  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         166  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         167  +
        _status: u16,
         168  +
        _body: &[u8],
         169  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         170  +
        Self::deserialize(deserializer)
         171  +
    }
         172  +
}
  162    173   
impl SseDescription {
  163    174   
    /// Creates a new builder-style object to manufacture [`SseDescription`](crate::types::SseDescription).
  164    175   
    pub fn builder() -> crate::types::builders::SseDescriptionBuilder {
  165    176   
        crate::types::builders::SseDescriptionBuilder::default()
  166    177   
    }
  167    178   
}
  168    179   
  169    180   
/// A builder for [`SseDescription`](crate::types::SseDescription).
  170    181   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  171    182   
#[non_exhaustive]

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

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

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

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

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

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

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

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

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

@@ -47,47 +177,177 @@
   67     67   
    "com.amazonaws.dynamodb",
   68     68   
    "TableCreationParameters",
   69     69   
);
   70     70   
static TABLECREATIONPARAMETERS_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.dynamodb#TableCreationParameters$TableName",
   73     73   
        "com.amazonaws.dynamodb",
   74     74   
        "TableCreationParameters",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "table_name",
          77  +
    "TableName",
   78     78   
    0,
   79     79   
);
   80     80   
static TABLECREATIONPARAMETERS_MEMBER_ATTRIBUTE_DEFINITIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static(
   82     82   
        "com.amazonaws.dynamodb#TableCreationParameters$AttributeDefinitions",
   83     83   
        "com.amazonaws.dynamodb",
   84     84   
        "TableCreationParameters",
   85     85   
    ),
   86     86   
    ::aws_smithy_schema::ShapeType::List,
   87         -
    "attribute_definitions",
          87  +
    "AttributeDefinitions",
   88     88   
    1,
   89     89   
);
   90     90   
static TABLECREATIONPARAMETERS_MEMBER_KEY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.dynamodb#TableCreationParameters$KeySchema",
   93     93   
        "com.amazonaws.dynamodb",
   94     94   
        "TableCreationParameters",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::List,
   97         -
    "key_schema",
          97  +
    "KeySchema",
   98     98   
    2,
   99     99   
);
  100    100   
static TABLECREATIONPARAMETERS_MEMBER_BILLING_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.dynamodb#TableCreationParameters$BillingMode",
  103    103   
        "com.amazonaws.dynamodb",
  104    104   
        "TableCreationParameters",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::String,
  107         -
    "billing_mode",
         107  +
    "BillingMode",
  108    108   
    3,
  109    109   
);
  110    110   
static TABLECREATIONPARAMETERS_MEMBER_PROVISIONED_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static(
  112    112   
        "com.amazonaws.dynamodb#TableCreationParameters$ProvisionedThroughput",
  113    113   
        "com.amazonaws.dynamodb",
  114    114   
        "TableCreationParameters",
  115    115   
    ),
  116    116   
    ::aws_smithy_schema::ShapeType::Structure,
  117         -
    "provisioned_throughput",
         117  +
    "ProvisionedThroughput",
  118    118   
    4,
  119    119   
);
  120    120   
static TABLECREATIONPARAMETERS_MEMBER_ON_DEMAND_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  121    121   
    ::aws_smithy_schema::ShapeId::from_static(
  122    122   
        "com.amazonaws.dynamodb#TableCreationParameters$OnDemandThroughput",
  123    123   
        "com.amazonaws.dynamodb",
  124    124   
        "TableCreationParameters",
  125    125   
    ),
  126    126   
    ::aws_smithy_schema::ShapeType::Structure,
  127         -
    "on_demand_throughput",
         127  +
    "OnDemandThroughput",
  128    128   
    5,
  129    129   
);
  130    130   
static TABLECREATIONPARAMETERS_MEMBER_SSE_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static(
  132    132   
        "com.amazonaws.dynamodb#TableCreationParameters$SSESpecification",
  133    133   
        "com.amazonaws.dynamodb",
  134    134   
        "TableCreationParameters",
  135    135   
    ),
  136    136   
    ::aws_smithy_schema::ShapeType::Structure,
  137         -
    "sse_specification",
         137  +
    "SSESpecification",
  138    138   
    6,
  139    139   
);
  140    140   
static TABLECREATIONPARAMETERS_MEMBER_GLOBAL_SECONDARY_INDEXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static(
  142    142   
        "com.amazonaws.dynamodb#TableCreationParameters$GlobalSecondaryIndexes",
  143    143   
        "com.amazonaws.dynamodb",
  144    144   
        "TableCreationParameters",
  145    145   
    ),
  146    146   
    ::aws_smithy_schema::ShapeType::List,
  147         -
    "global_secondary_indexes",
         147  +
    "GlobalSecondaryIndexes",
  148    148   
    7,
  149    149   
);
  150    150   
static TABLECREATIONPARAMETERS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  151    151   
    TABLECREATIONPARAMETERS_SCHEMA_ID,
  152    152   
    ::aws_smithy_schema::ShapeType::Structure,
  153    153   
    &[
  154    154   
        &TABLECREATIONPARAMETERS_MEMBER_TABLE_NAME,
  155    155   
        &TABLECREATIONPARAMETERS_MEMBER_ATTRIBUTE_DEFINITIONS,
  156    156   
        &TABLECREATIONPARAMETERS_MEMBER_KEY_SCHEMA,
  157    157   
        &TABLECREATIONPARAMETERS_MEMBER_BILLING_MODE,
@@ -202,202 +338,343 @@
  222    222   
                    }
  223    223   
                    Ok(())
  224    224   
                },
  225    225   
            )?;
  226    226   
        }
  227    227   
        Ok(())
  228    228   
    }
  229    229   
}
  230    230   
impl TableCreationParameters {
  231    231   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  232         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  233         -
        deserializer: &mut D,
         232  +
    pub fn deserialize(
         233  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  234    234   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  235    235   
        #[allow(unused_variables, unused_mut)]
  236    236   
        let mut builder = Self::builder();
  237    237   
        #[allow(
  238    238   
            unused_variables,
  239    239   
            unreachable_code,
  240    240   
            clippy::single_match,
  241    241   
            clippy::match_single_binding,
  242    242   
            clippy::diverging_sub_expression
  243    243   
        )]
  244         -
        deserializer.read_struct(&TABLECREATIONPARAMETERS_SCHEMA, (), |_, member, deser| {
         244  +
        deserializer.read_struct(&TABLECREATIONPARAMETERS_SCHEMA, &mut |member, deser| {
  245    245   
            match member.member_index() {
  246    246   
                Some(0) => {
  247    247   
                    builder.table_name = Some(deser.read_string(member)?);
  248    248   
                }
  249    249   
                Some(1) => {
  250    250   
                    builder.attribute_definitions = Some({
  251         -
                        let container = if let Some(cap) = deser.container_size() {
  252         -
                            Vec::with_capacity(cap)
  253         -
                        } else {
  254         -
                            Vec::new()
  255         -
                        };
  256         -
                        deser.read_list(member, container, |mut list, deser| {
  257         -
                            list.push(crate::types::AttributeDefinition::deserialize(deser)?);
  258         -
                            Ok(list)
  259         -
                        })?
         251  +
                        let mut container = Vec::new();
         252  +
                        deser.read_list(member, &mut |deser| {
         253  +
                            container.push(crate::types::AttributeDefinition::deserialize(deser)?);
         254  +
                            Ok(())
         255  +
                        })?;
         256  +
                        container
  260    257   
                    });
  261    258   
                }
  262    259   
                Some(2) => {
  263    260   
                    builder.key_schema = Some({
  264         -
                        let container = if let Some(cap) = deser.container_size() {
  265         -
                            Vec::with_capacity(cap)
  266         -
                        } else {
  267         -
                            Vec::new()
  268         -
                        };
  269         -
                        deser.read_list(member, container, |mut list, deser| {
  270         -
                            list.push(crate::types::KeySchemaElement::deserialize(deser)?);
  271         -
                            Ok(list)
  272         -
                        })?
         261  +
                        let mut container = Vec::new();
         262  +
                        deser.read_list(member, &mut |deser| {
         263  +
                            container.push(crate::types::KeySchemaElement::deserialize(deser)?);
         264  +
                            Ok(())
         265  +
                        })?;
         266  +
                        container
  273    267   
                    });
  274    268   
                }
  275    269   
                Some(3) => {
  276    270   
                    builder.billing_mode = Some(crate::types::BillingMode::from(deser.read_string(member)?.as_str()));
  277    271   
                }
  278    272   
                Some(4) => {
  279    273   
                    builder.provisioned_throughput = Some(crate::types::ProvisionedThroughput::deserialize(deser)?);
  280    274   
                }
  281    275   
                Some(5) => {
  282    276   
                    builder.on_demand_throughput = Some(crate::types::OnDemandThroughput::deserialize(deser)?);
  283    277   
                }
  284    278   
                Some(6) => {
  285    279   
                    builder.sse_specification = Some(crate::types::SseSpecification::deserialize(deser)?);
  286    280   
                }
  287    281   
                Some(7) => {
  288    282   
                    builder.global_secondary_indexes = Some({
  289         -
                        let container = if let Some(cap) = deser.container_size() {
  290         -
                            Vec::with_capacity(cap)
  291         -
                        } else {
  292         -
                            Vec::new()
  293         -
                        };
  294         -
                        deser.read_list(member, container, |mut list, deser| {
  295         -
                            list.push(crate::types::GlobalSecondaryIndex::deserialize(deser)?);
  296         -
                            Ok(list)
  297         -
                        })?
         283  +
                        let mut container = Vec::new();
         284  +
                        deser.read_list(member, &mut |deser| {
         285  +
                            container.push(crate::types::GlobalSecondaryIndex::deserialize(deser)?);
         286  +
                            Ok(())
         287  +
                        })?;
         288  +
                        container
  298    289   
                    });
  299    290   
                }
  300    291   
                _ => {}
  301    292   
            }
  302    293   
            Ok(())
  303    294   
        })?;
         295  +
        builder.table_name = builder.table_name.or(Some(String::new()));
         296  +
        builder.attribute_definitions = builder.attribute_definitions.or(Some(Vec::new()));
         297  +
        builder.key_schema = builder.key_schema.or(Some(Vec::new()));
  304    298   
        builder
  305    299   
            .build()
  306    300   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  307    301   
    }
  308    302   
}
         303  +
impl TableCreationParameters {
         304  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         305  +
    pub fn deserialize_with_response(
         306  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         307  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         308  +
        _status: u16,
         309  +
        _body: &[u8],
         310  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         311  +
        Self::deserialize(deserializer)
         312  +
    }
         313  +
}
  309    314   
impl TableCreationParameters {
  310    315   
    /// Creates a new builder-style object to manufacture [`TableCreationParameters`](crate::types::TableCreationParameters).
  311    316   
    pub fn builder() -> crate::types::builders::TableCreationParametersBuilder {
  312    317   
        crate::types::builders::TableCreationParametersBuilder::default()
  313    318   
    }
  314    319   
}
  315    320   
  316    321   
/// A builder for [`TableCreationParameters`](crate::types::TableCreationParameters).
  317    322   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  318    323   
#[non_exhaustive]

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

@@ -415,415 +735,735 @@
  435    435   
}
  436    436   
static TABLEDESCRIPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  437    437   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#TableDescription", "com.amazonaws.dynamodb", "TableDescription");
  438    438   
static TABLEDESCRIPTION_MEMBER_ATTRIBUTE_DEFINITIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  439    439   
    ::aws_smithy_schema::ShapeId::from_static(
  440    440   
        "com.amazonaws.dynamodb#TableDescription$AttributeDefinitions",
  441    441   
        "com.amazonaws.dynamodb",
  442    442   
        "TableDescription",
  443    443   
    ),
  444    444   
    ::aws_smithy_schema::ShapeType::List,
  445         -
    "attribute_definitions",
         445  +
    "AttributeDefinitions",
  446    446   
    0,
  447    447   
);
  448    448   
static TABLEDESCRIPTION_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  449    449   
    ::aws_smithy_schema::ShapeId::from_static(
  450    450   
        "com.amazonaws.dynamodb#TableDescription$TableName",
  451    451   
        "com.amazonaws.dynamodb",
  452    452   
        "TableDescription",
  453    453   
    ),
  454    454   
    ::aws_smithy_schema::ShapeType::String,
  455         -
    "table_name",
         455  +
    "TableName",
  456    456   
    1,
  457    457   
);
  458    458   
static TABLEDESCRIPTION_MEMBER_KEY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  459    459   
    ::aws_smithy_schema::ShapeId::from_static(
  460    460   
        "com.amazonaws.dynamodb#TableDescription$KeySchema",
  461    461   
        "com.amazonaws.dynamodb",
  462    462   
        "TableDescription",
  463    463   
    ),
  464    464   
    ::aws_smithy_schema::ShapeType::List,
  465         -
    "key_schema",
         465  +
    "KeySchema",
  466    466   
    2,
  467    467   
);
  468    468   
static TABLEDESCRIPTION_MEMBER_TABLE_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  469    469   
    ::aws_smithy_schema::ShapeId::from_static(
  470    470   
        "com.amazonaws.dynamodb#TableDescription$TableStatus",
  471    471   
        "com.amazonaws.dynamodb",
  472    472   
        "TableDescription",
  473    473   
    ),
  474    474   
    ::aws_smithy_schema::ShapeType::String,
  475         -
    "table_status",
         475  +
    "TableStatus",
  476    476   
    3,
  477    477   
);
  478    478   
static TABLEDESCRIPTION_MEMBER_CREATION_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  479    479   
    ::aws_smithy_schema::ShapeId::from_static(
  480    480   
        "com.amazonaws.dynamodb#TableDescription$CreationDateTime",
  481    481   
        "com.amazonaws.dynamodb",
  482    482   
        "TableDescription",
  483    483   
    ),
  484    484   
    ::aws_smithy_schema::ShapeType::Timestamp,
  485         -
    "creation_date_time",
         485  +
    "CreationDateTime",
  486    486   
    4,
  487    487   
);
  488    488   
static TABLEDESCRIPTION_MEMBER_PROVISIONED_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  489    489   
    ::aws_smithy_schema::ShapeId::from_static(
  490    490   
        "com.amazonaws.dynamodb#TableDescription$ProvisionedThroughput",
  491    491   
        "com.amazonaws.dynamodb",
  492    492   
        "TableDescription",
  493    493   
    ),
  494    494   
    ::aws_smithy_schema::ShapeType::Structure,
  495         -
    "provisioned_throughput",
         495  +
    "ProvisionedThroughput",
  496    496   
    5,
  497    497   
);
  498    498   
static TABLEDESCRIPTION_MEMBER_TABLE_SIZE_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  499    499   
    ::aws_smithy_schema::ShapeId::from_static(
  500    500   
        "com.amazonaws.dynamodb#TableDescription$TableSizeBytes",
  501    501   
        "com.amazonaws.dynamodb",
  502    502   
        "TableDescription",
  503    503   
    ),
  504    504   
    ::aws_smithy_schema::ShapeType::Long,
  505         -
    "table_size_bytes",
         505  +
    "TableSizeBytes",
  506    506   
    6,
  507    507   
);
  508    508   
static TABLEDESCRIPTION_MEMBER_ITEM_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  509    509   
    ::aws_smithy_schema::ShapeId::from_static(
  510    510   
        "com.amazonaws.dynamodb#TableDescription$ItemCount",
  511    511   
        "com.amazonaws.dynamodb",
  512    512   
        "TableDescription",
  513    513   
    ),
  514    514   
    ::aws_smithy_schema::ShapeType::Long,
  515         -
    "item_count",
         515  +
    "ItemCount",
  516    516   
    7,
  517    517   
);
  518    518   
static TABLEDESCRIPTION_MEMBER_TABLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  519    519   
    ::aws_smithy_schema::ShapeId::from_static(
  520    520   
        "com.amazonaws.dynamodb#TableDescription$TableArn",
  521    521   
        "com.amazonaws.dynamodb",
  522    522   
        "TableDescription",
  523    523   
    ),
  524    524   
    ::aws_smithy_schema::ShapeType::String,
  525         -
    "table_arn",
         525  +
    "TableArn",
  526    526   
    8,
  527    527   
);
  528    528   
static TABLEDESCRIPTION_MEMBER_TABLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  529    529   
    ::aws_smithy_schema::ShapeId::from_static(
  530    530   
        "com.amazonaws.dynamodb#TableDescription$TableId",
  531    531   
        "com.amazonaws.dynamodb",
  532    532   
        "TableDescription",
  533    533   
    ),
  534    534   
    ::aws_smithy_schema::ShapeType::String,
  535         -
    "table_id",
         535  +
    "TableId",
  536    536   
    9,
  537    537   
);
  538    538   
static TABLEDESCRIPTION_MEMBER_BILLING_MODE_SUMMARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  539    539   
    ::aws_smithy_schema::ShapeId::from_static(
  540    540   
        "com.amazonaws.dynamodb#TableDescription$BillingModeSummary",
  541    541   
        "com.amazonaws.dynamodb",
  542    542   
        "TableDescription",
  543    543   
    ),
  544    544   
    ::aws_smithy_schema::ShapeType::Structure,
  545         -
    "billing_mode_summary",
         545  +
    "BillingModeSummary",
  546    546   
    10,
  547    547   
);
  548    548   
static TABLEDESCRIPTION_MEMBER_LOCAL_SECONDARY_INDEXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  549    549   
    ::aws_smithy_schema::ShapeId::from_static(
  550    550   
        "com.amazonaws.dynamodb#TableDescription$LocalSecondaryIndexes",
  551    551   
        "com.amazonaws.dynamodb",
  552    552   
        "TableDescription",
  553    553   
    ),
  554    554   
    ::aws_smithy_schema::ShapeType::List,
  555         -
    "local_secondary_indexes",
         555  +
    "LocalSecondaryIndexes",
  556    556   
    11,
  557    557   
);
  558    558   
static TABLEDESCRIPTION_MEMBER_GLOBAL_SECONDARY_INDEXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  559    559   
    ::aws_smithy_schema::ShapeId::from_static(
  560    560   
        "com.amazonaws.dynamodb#TableDescription$GlobalSecondaryIndexes",
  561    561   
        "com.amazonaws.dynamodb",
  562    562   
        "TableDescription",
  563    563   
    ),
  564    564   
    ::aws_smithy_schema::ShapeType::List,
  565         -
    "global_secondary_indexes",
         565  +
    "GlobalSecondaryIndexes",
  566    566   
    12,
  567    567   
);
  568    568   
static TABLEDESCRIPTION_MEMBER_STREAM_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  569    569   
    ::aws_smithy_schema::ShapeId::from_static(
  570    570   
        "com.amazonaws.dynamodb#TableDescription$StreamSpecification",
  571    571   
        "com.amazonaws.dynamodb",
  572    572   
        "TableDescription",
  573    573   
    ),
  574    574   
    ::aws_smithy_schema::ShapeType::Structure,
  575         -
    "stream_specification",
         575  +
    "StreamSpecification",
  576    576   
    13,
  577    577   
);
  578    578   
static TABLEDESCRIPTION_MEMBER_LATEST_STREAM_LABEL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  579    579   
    ::aws_smithy_schema::ShapeId::from_static(
  580    580   
        "com.amazonaws.dynamodb#TableDescription$LatestStreamLabel",
  581    581   
        "com.amazonaws.dynamodb",
  582    582   
        "TableDescription",
  583    583   
    ),
  584    584   
    ::aws_smithy_schema::ShapeType::String,
  585         -
    "latest_stream_label",
         585  +
    "LatestStreamLabel",
  586    586   
    14,
  587    587   
);
  588    588   
static TABLEDESCRIPTION_MEMBER_LATEST_STREAM_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  589    589   
    ::aws_smithy_schema::ShapeId::from_static(
  590    590   
        "com.amazonaws.dynamodb#TableDescription$LatestStreamArn",
  591    591   
        "com.amazonaws.dynamodb",
  592    592   
        "TableDescription",
  593    593   
    ),
  594    594   
    ::aws_smithy_schema::ShapeType::String,
  595         -
    "latest_stream_arn",
         595  +
    "LatestStreamArn",
  596    596   
    15,
  597    597   
);
  598    598   
static TABLEDESCRIPTION_MEMBER_GLOBAL_TABLE_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  599    599   
    ::aws_smithy_schema::ShapeId::from_static(
  600    600   
        "com.amazonaws.dynamodb#TableDescription$GlobalTableVersion",
  601    601   
        "com.amazonaws.dynamodb",
  602    602   
        "TableDescription",
  603    603   
    ),
  604    604   
    ::aws_smithy_schema::ShapeType::String,
  605         -
    "global_table_version",
         605  +
    "GlobalTableVersion",
  606    606   
    16,
  607    607   
);
  608    608   
static TABLEDESCRIPTION_MEMBER_REPLICAS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  609    609   
    ::aws_smithy_schema::ShapeId::from_static(
  610    610   
        "com.amazonaws.dynamodb#TableDescription$Replicas",
  611    611   
        "com.amazonaws.dynamodb",
  612    612   
        "TableDescription",
  613    613   
    ),
  614    614   
    ::aws_smithy_schema::ShapeType::List,
  615         -
    "replicas",
         615  +
    "Replicas",
  616    616   
    17,
  617    617   
);
  618    618   
static TABLEDESCRIPTION_MEMBER_GLOBAL_TABLE_WITNESSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  619    619   
    ::aws_smithy_schema::ShapeId::from_static(
  620    620   
        "com.amazonaws.dynamodb#TableDescription$GlobalTableWitnesses",
  621    621   
        "com.amazonaws.dynamodb",
  622    622   
        "TableDescription",
  623    623   
    ),
  624    624   
    ::aws_smithy_schema::ShapeType::List,
  625         -
    "global_table_witnesses",
         625  +
    "GlobalTableWitnesses",
  626    626   
    18,
  627    627   
);
  628    628   
static TABLEDESCRIPTION_MEMBER_RESTORE_SUMMARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  629    629   
    ::aws_smithy_schema::ShapeId::from_static(
  630    630   
        "com.amazonaws.dynamodb#TableDescription$RestoreSummary",
  631    631   
        "com.amazonaws.dynamodb",
  632    632   
        "TableDescription",
  633    633   
    ),
  634    634   
    ::aws_smithy_schema::ShapeType::Structure,
  635         -
    "restore_summary",
         635  +
    "RestoreSummary",
  636    636   
    19,
  637    637   
);
  638    638   
static TABLEDESCRIPTION_MEMBER_SSE_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  639    639   
    ::aws_smithy_schema::ShapeId::from_static(
  640    640   
        "com.amazonaws.dynamodb#TableDescription$SSEDescription",
  641    641   
        "com.amazonaws.dynamodb",
  642    642   
        "TableDescription",
  643    643   
    ),
  644    644   
    ::aws_smithy_schema::ShapeType::Structure,
  645         -
    "sse_description",
         645  +
    "SSEDescription",
  646    646   
    20,
  647    647   
);
  648    648   
static TABLEDESCRIPTION_MEMBER_ARCHIVAL_SUMMARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  649    649   
    ::aws_smithy_schema::ShapeId::from_static(
  650    650   
        "com.amazonaws.dynamodb#TableDescription$ArchivalSummary",
  651    651   
        "com.amazonaws.dynamodb",
  652    652   
        "TableDescription",
  653    653   
    ),
  654    654   
    ::aws_smithy_schema::ShapeType::Structure,
  655         -
    "archival_summary",
         655  +
    "ArchivalSummary",
  656    656   
    21,
  657    657   
);
  658    658   
static TABLEDESCRIPTION_MEMBER_TABLE_CLASS_SUMMARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  659    659   
    ::aws_smithy_schema::ShapeId::from_static(
  660    660   
        "com.amazonaws.dynamodb#TableDescription$TableClassSummary",
  661    661   
        "com.amazonaws.dynamodb",
  662    662   
        "TableDescription",
  663    663   
    ),
  664    664   
    ::aws_smithy_schema::ShapeType::Structure,
  665         -
    "table_class_summary",
         665  +
    "TableClassSummary",
  666    666   
    22,
  667    667   
);
  668    668   
static TABLEDESCRIPTION_MEMBER_DELETION_PROTECTION_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  669    669   
    ::aws_smithy_schema::ShapeId::from_static(
  670    670   
        "com.amazonaws.dynamodb#TableDescription$DeletionProtectionEnabled",
  671    671   
        "com.amazonaws.dynamodb",
  672    672   
        "TableDescription",
  673    673   
    ),
  674    674   
    ::aws_smithy_schema::ShapeType::Boolean,
  675         -
    "deletion_protection_enabled",
         675  +
    "DeletionProtectionEnabled",
  676    676   
    23,
  677    677   
);
  678    678   
static TABLEDESCRIPTION_MEMBER_ON_DEMAND_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  679    679   
    ::aws_smithy_schema::ShapeId::from_static(
  680    680   
        "com.amazonaws.dynamodb#TableDescription$OnDemandThroughput",
  681    681   
        "com.amazonaws.dynamodb",
  682    682   
        "TableDescription",
  683    683   
    ),
  684    684   
    ::aws_smithy_schema::ShapeType::Structure,
  685         -
    "on_demand_throughput",
         685  +
    "OnDemandThroughput",
  686    686   
    24,
  687    687   
);
  688    688   
static TABLEDESCRIPTION_MEMBER_WARM_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  689    689   
    ::aws_smithy_schema::ShapeId::from_static(
  690    690   
        "com.amazonaws.dynamodb#TableDescription$WarmThroughput",
  691    691   
        "com.amazonaws.dynamodb",
  692    692   
        "TableDescription",
  693    693   
    ),
  694    694   
    ::aws_smithy_schema::ShapeType::Structure,
  695         -
    "warm_throughput",
         695  +
    "WarmThroughput",
  696    696   
    25,
  697    697   
);
  698    698   
static TABLEDESCRIPTION_MEMBER_MULTI_REGION_CONSISTENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  699    699   
    ::aws_smithy_schema::ShapeId::from_static(
  700    700   
        "com.amazonaws.dynamodb#TableDescription$MultiRegionConsistency",
  701    701   
        "com.amazonaws.dynamodb",
  702    702   
        "TableDescription",
  703    703   
    ),
  704    704   
    ::aws_smithy_schema::ShapeType::String,
  705         -
    "multi_region_consistency",
         705  +
    "MultiRegionConsistency",
  706    706   
    26,
  707    707   
);
  708    708   
static TABLEDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  709    709   
    TABLEDESCRIPTION_SCHEMA_ID,
  710    710   
    ::aws_smithy_schema::ShapeType::Structure,
  711    711   
    &[
  712    712   
        &TABLEDESCRIPTION_MEMBER_ATTRIBUTE_DEFINITIONS,
  713    713   
        &TABLEDESCRIPTION_MEMBER_TABLE_NAME,
  714    714   
        &TABLEDESCRIPTION_MEMBER_KEY_SCHEMA,
  715    715   
        &TABLEDESCRIPTION_MEMBER_TABLE_STATUS,
@@ -855,855 +1076,1069 @@
  875    875   
            ser.write_struct(&TABLEDESCRIPTION_MEMBER_WARM_THROUGHPUT, val)?;
  876    876   
        }
  877    877   
        if let Some(ref val) = self.multi_region_consistency {
  878    878   
            ser.write_string(&TABLEDESCRIPTION_MEMBER_MULTI_REGION_CONSISTENCY, val.as_str())?;
  879    879   
        }
  880    880   
        Ok(())
  881    881   
    }
  882    882   
}
  883    883   
impl TableDescription {
  884    884   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  885         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  886         -
        deserializer: &mut D,
         885  +
    pub fn deserialize(
         886  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  887    887   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  888    888   
        #[allow(unused_variables, unused_mut)]
  889    889   
        let mut builder = Self::builder();
  890    890   
        #[allow(
  891    891   
            unused_variables,
  892    892   
            unreachable_code,
  893    893   
            clippy::single_match,
  894    894   
            clippy::match_single_binding,
  895    895   
            clippy::diverging_sub_expression
  896    896   
        )]
  897         -
        deserializer.read_struct(&TABLEDESCRIPTION_SCHEMA, (), |_, member, deser| {
         897  +
        deserializer.read_struct(&TABLEDESCRIPTION_SCHEMA, &mut |member, deser| {
  898    898   
            match member.member_index() {
  899    899   
                Some(0) => {
  900    900   
                    builder.attribute_definitions = Some({
  901         -
                        let container = if let Some(cap) = deser.container_size() {
  902         -
                            Vec::with_capacity(cap)
  903         -
                        } else {
  904         -
                            Vec::new()
  905         -
                        };
  906         -
                        deser.read_list(member, container, |mut list, deser| {
  907         -
                            list.push(crate::types::AttributeDefinition::deserialize(deser)?);
  908         -
                            Ok(list)
  909         -
                        })?
         901  +
                        let mut container = Vec::new();
         902  +
                        deser.read_list(member, &mut |deser| {
         903  +
                            container.push(crate::types::AttributeDefinition::deserialize(deser)?);
         904  +
                            Ok(())
         905  +
                        })?;
         906  +
                        container
  910    907   
                    });
  911    908   
                }
  912    909   
                Some(1) => {
  913    910   
                    builder.table_name = Some(deser.read_string(member)?);
  914    911   
                }
  915    912   
                Some(2) => {
  916    913   
                    builder.key_schema = Some({
  917         -
                        let container = if let Some(cap) = deser.container_size() {
  918         -
                            Vec::with_capacity(cap)
  919         -
                        } else {
  920         -
                            Vec::new()
  921         -
                        };
  922         -
                        deser.read_list(member, container, |mut list, deser| {
  923         -
                            list.push(crate::types::KeySchemaElement::deserialize(deser)?);
  924         -
                            Ok(list)
  925         -
                        })?
         914  +
                        let mut container = Vec::new();
         915  +
                        deser.read_list(member, &mut |deser| {
         916  +
                            container.push(crate::types::KeySchemaElement::deserialize(deser)?);
         917  +
                            Ok(())
         918  +
                        })?;
         919  +
                        container
  926    920   
                    });
  927    921   
                }
  928    922   
                Some(3) => {
  929    923   
                    builder.table_status = Some(crate::types::TableStatus::from(deser.read_string(member)?.as_str()));
  930    924   
                }
  931    925   
                Some(4) => {
  932    926   
                    builder.creation_date_time = Some(deser.read_timestamp(member)?);
  933    927   
                }
  934    928   
                Some(5) => {
  935    929   
                    builder.provisioned_throughput = Some(crate::types::ProvisionedThroughputDescription::deserialize(deser)?);
  936    930   
                }
  937    931   
                Some(6) => {
  938    932   
                    builder.table_size_bytes = Some(deser.read_long(member)?);
  939    933   
                }
  940    934   
                Some(7) => {
  941    935   
                    builder.item_count = Some(deser.read_long(member)?);
  942    936   
                }
  943    937   
                Some(8) => {
  944    938   
                    builder.table_arn = Some(deser.read_string(member)?);
  945    939   
                }
  946    940   
                Some(9) => {
  947    941   
                    builder.table_id = Some(deser.read_string(member)?);
  948    942   
                }
  949    943   
                Some(10) => {
  950    944   
                    builder.billing_mode_summary = Some(crate::types::BillingModeSummary::deserialize(deser)?);
  951    945   
                }
  952    946   
                Some(11) => {
  953    947   
                    builder.local_secondary_indexes = Some({
  954         -
                        let container = if let Some(cap) = deser.container_size() {
  955         -
                            Vec::with_capacity(cap)
  956         -
                        } else {
  957         -
                            Vec::new()
  958         -
                        };
  959         -
                        deser.read_list(member, container, |mut list, deser| {
  960         -
                            list.push(crate::types::LocalSecondaryIndexDescription::deserialize(deser)?);
  961         -
                            Ok(list)
  962         -
                        })?
         948  +
                        let mut container = Vec::new();
         949  +
                        deser.read_list(member, &mut |deser| {
         950  +
                            container.push(crate::types::LocalSecondaryIndexDescription::deserialize(deser)?);
         951  +
                            Ok(())
         952  +
                        })?;
         953  +
                        container
  963    954   
                    });
  964    955   
                }
  965    956   
                Some(12) => {
  966    957   
                    builder.global_secondary_indexes = Some({
  967         -
                        let container = if let Some(cap) = deser.container_size() {
  968         -
                            Vec::with_capacity(cap)
  969         -
                        } else {
  970         -
                            Vec::new()
  971         -
                        };
  972         -
                        deser.read_list(member, container, |mut list, deser| {
  973         -
                            list.push(crate::types::GlobalSecondaryIndexDescription::deserialize(deser)?);
  974         -
                            Ok(list)
  975         -
                        })?
         958  +
                        let mut container = Vec::new();
         959  +
                        deser.read_list(member, &mut |deser| {
         960  +
                            container.push(crate::types::GlobalSecondaryIndexDescription::deserialize(deser)?);
         961  +
                            Ok(())
         962  +
                        })?;
         963  +
                        container
  976    964   
                    });
  977    965   
                }
  978    966   
                Some(13) => {
  979    967   
                    builder.stream_specification = Some(crate::types::StreamSpecification::deserialize(deser)?);
  980    968   
                }
  981    969   
                Some(14) => {
  982    970   
                    builder.latest_stream_label = Some(deser.read_string(member)?);
  983    971   
                }
  984    972   
                Some(15) => {
  985    973   
                    builder.latest_stream_arn = Some(deser.read_string(member)?);
  986    974   
                }
  987    975   
                Some(16) => {
  988    976   
                    builder.global_table_version = Some(deser.read_string(member)?);
  989    977   
                }
  990    978   
                Some(17) => {
  991    979   
                    builder.replicas = Some({
  992         -
                        let container = if let Some(cap) = deser.container_size() {
  993         -
                            Vec::with_capacity(cap)
  994         -
                        } else {
  995         -
                            Vec::new()
  996         -
                        };
  997         -
                        deser.read_list(member, container, |mut list, deser| {
  998         -
                            list.push(crate::types::ReplicaDescription::deserialize(deser)?);
  999         -
                            Ok(list)
 1000         -
                        })?
         980  +
                        let mut container = Vec::new();
         981  +
                        deser.read_list(member, &mut |deser| {
         982  +
                            container.push(crate::types::ReplicaDescription::deserialize(deser)?);
         983  +
                            Ok(())
         984  +
                        })?;
         985  +
                        container
 1001    986   
                    });
 1002    987   
                }
 1003    988   
                Some(18) => {
 1004    989   
                    builder.global_table_witnesses = Some({
 1005         -
                        let container = if let Some(cap) = deser.container_size() {
 1006         -
                            Vec::with_capacity(cap)
 1007         -
                        } else {
 1008         -
                            Vec::new()
 1009         -
                        };
 1010         -
                        deser.read_list(member, container, |mut list, deser| {
 1011         -
                            list.push(crate::types::GlobalTableWitnessDescription::deserialize(deser)?);
 1012         -
                            Ok(list)
 1013         -
                        })?
         990  +
                        let mut container = Vec::new();
         991  +
                        deser.read_list(member, &mut |deser| {
         992  +
                            container.push(crate::types::GlobalTableWitnessDescription::deserialize(deser)?);
         993  +
                            Ok(())
         994  +
                        })?;
         995  +
                        container
 1014    996   
                    });
 1015    997   
                }
 1016    998   
                Some(19) => {
 1017    999   
                    builder.restore_summary = Some(crate::types::RestoreSummary::deserialize(deser)?);
 1018   1000   
                }
 1019   1001   
                Some(20) => {
 1020   1002   
                    builder.sse_description = Some(crate::types::SseDescription::deserialize(deser)?);
 1021   1003   
                }
 1022   1004   
                Some(21) => {
 1023   1005   
                    builder.archival_summary = Some(crate::types::ArchivalSummary::deserialize(deser)?);
 1024   1006   
                }
 1025   1007   
                Some(22) => {
 1026   1008   
                    builder.table_class_summary = Some(crate::types::TableClassSummary::deserialize(deser)?);
 1027   1009   
                }
 1028   1010   
                Some(23) => {
 1029   1011   
                    builder.deletion_protection_enabled = Some(deser.read_boolean(member)?);
 1030   1012   
                }
 1031   1013   
                Some(24) => {
 1032   1014   
                    builder.on_demand_throughput = Some(crate::types::OnDemandThroughput::deserialize(deser)?);
 1033   1015   
                }
 1034   1016   
                Some(25) => {
 1035   1017   
                    builder.warm_throughput = Some(crate::types::TableWarmThroughputDescription::deserialize(deser)?);
 1036   1018   
                }
 1037   1019   
                Some(26) => {
 1038   1020   
                    builder.multi_region_consistency = Some(crate::types::MultiRegionConsistency::from(deser.read_string(member)?.as_str()));
 1039   1021   
                }
 1040   1022   
                _ => {}
 1041   1023   
            }
 1042   1024   
            Ok(())
 1043   1025   
        })?;
 1044   1026   
        Ok(builder.build())
 1045   1027   
    }
 1046   1028   
}
        1029  +
impl TableDescription {
        1030  +
    /// Deserializes this structure from a body deserializer and HTTP response.
        1031  +
    pub fn deserialize_with_response(
        1032  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
        1033  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
        1034  +
        _status: u16,
        1035  +
        _body: &[u8],
        1036  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
        1037  +
        Self::deserialize(deserializer)
        1038  +
    }
        1039  +
}
 1047   1040   
impl TableDescription {
 1048   1041   
    /// Creates a new builder-style object to manufacture [`TableDescription`](crate::types::TableDescription).
 1049   1042   
    pub fn builder() -> crate::types::builders::TableDescriptionBuilder {
 1050   1043   
        crate::types::builders::TableDescriptionBuilder::default()
 1051   1044   
    }
 1052   1045   
}
 1053   1046   
 1054   1047   
/// A builder for [`TableDescription`](crate::types::TableDescription).
 1055   1048   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 1056   1049   
#[non_exhaustive]