Client Test

Client Test

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_global_table_global_secondary_index_settings_update.rs

@@ -11,11 +168,180 @@
   31     31   
    "com.amazonaws.dynamodb",
   32     32   
    "GlobalTableGlobalSecondaryIndexSettingsUpdate",
   33     33   
);
   34     34   
static GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_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#GlobalTableGlobalSecondaryIndexSettingsUpdate$IndexName",
   37     37   
        "com.amazonaws.dynamodb",
   38     38   
        "GlobalTableGlobalSecondaryIndexSettingsUpdate",
   39     39   
    ),
   40     40   
    ::aws_smithy_schema::ShapeType::String,
   41         -
    "index_name",
          41  +
    "IndexName",
   42     42   
    0,
   43     43   
);
   44     44   
static GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_MEMBER_PROVISIONED_WRITE_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#GlobalTableGlobalSecondaryIndexSettingsUpdate$ProvisionedWriteCapacityUnits",
   48     48   
            "com.amazonaws.dynamodb",
   49     49   
            "GlobalTableGlobalSecondaryIndexSettingsUpdate",
   50     50   
        ),
   51     51   
        ::aws_smithy_schema::ShapeType::Long,
   52         -
        "provisioned_write_capacity_units",
          52  +
        "ProvisionedWriteCapacityUnits",
   53     53   
        1,
   54     54   
    );
   55     55   
static GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_MEMBER_PROVISIONED_WRITE_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#GlobalTableGlobalSecondaryIndexSettingsUpdate$ProvisionedWriteCapacityAutoScalingSettingsUpdate",
   59     59   
            "com.amazonaws.dynamodb",
   60     60   
            "GlobalTableGlobalSecondaryIndexSettingsUpdate",
   61     61   
        ),
   62     62   
        ::aws_smithy_schema::ShapeType::Structure,
   63         -
        "provisioned_write_capacity_auto_scaling_settings_update",
          63  +
        "ProvisionedWriteCapacityAutoScalingSettingsUpdate",
   64     64   
        2,
   65     65   
    );
   66     66   
static GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   67     67   
    GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_SCHEMA_ID,
   68     68   
    ::aws_smithy_schema::ShapeType::Structure,
   69     69   
    &[
   70     70   
        &GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_MEMBER_INDEX_NAME,
   71     71   
        &GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_MEMBER_PROVISIONED_WRITE_CAPACITY_UNITS,
   72     72   
        &GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_MEMBER_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_SETTINGS_UPDATE,
   73     73   
    ],
   74     74   
);
   75     75   
impl GlobalTableGlobalSecondaryIndexSettingsUpdate {
   76     76   
    /// The schema for this shape.
   77     77   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_SCHEMA;
   78     78   
}
   79     79   
impl ::aws_smithy_schema::serde::SerializableStruct for GlobalTableGlobalSecondaryIndexSettingsUpdate {
   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(&GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_MEMBER_INDEX_NAME, val)?;
   88     88   
        }
   89     89   
        if let Some(ref val) = self.provisioned_write_capacity_units {
   90     90   
            ser.write_long(
   91     91   
                &GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_MEMBER_PROVISIONED_WRITE_CAPACITY_UNITS,
   92     92   
                *val,
   93     93   
            )?;
   94     94   
        }
   95     95   
        if let Some(ref val) = self.provisioned_write_capacity_auto_scaling_settings_update {
   96     96   
            ser.write_struct(
   97     97   
                &GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_MEMBER_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_SETTINGS_UPDATE,
   98     98   
                val,
   99     99   
            )?;
  100    100   
        }
  101    101   
        Ok(())
  102    102   
    }
  103    103   
}
  104    104   
impl GlobalTableGlobalSecondaryIndexSettingsUpdate {
  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(&GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_SCHEMA, (), |_, member, deser| {
         118  +
        deserializer.read_struct(&GLOBALTABLEGLOBALSECONDARYINDEXSETTINGSUPDATE_SCHEMA, &mut |member, deser| {
  119    119   
            match member.member_index() {
  120    120   
                Some(0) => {
  121    121   
                    builder.index_name = Some(deser.read_string(member)?);
  122    122   
                }
  123    123   
                Some(1) => {
  124    124   
                    builder.provisioned_write_capacity_units = Some(deser.read_long(member)?);
  125    125   
                }
  126    126   
                Some(2) => {
  127    127   
                    builder.provisioned_write_capacity_auto_scaling_settings_update =
  128    128   
                        Some(crate::types::AutoScalingSettingsUpdate::deserialize(deser)?);
  129    129   
                }
  130    130   
                _ => {}
  131    131   
            }
  132    132   
            Ok(())
  133    133   
        })?;
         134  +
        builder.index_name = builder.index_name.or(Some(String::new()));
  134    135   
        builder
  135    136   
            .build()
  136    137   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  137    138   
    }
  138    139   
}
         140  +
impl GlobalTableGlobalSecondaryIndexSettingsUpdate {
         141  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         142  +
    pub fn deserialize_with_response(
         143  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         144  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         145  +
        _status: u16,
         146  +
        _body: &[u8],
         147  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         148  +
        Self::deserialize(deserializer)
         149  +
    }
         150  +
}
  139    151   
impl GlobalTableGlobalSecondaryIndexSettingsUpdate {
  140    152   
    /// Creates a new builder-style object to manufacture [`GlobalTableGlobalSecondaryIndexSettingsUpdate`](crate::types::GlobalTableGlobalSecondaryIndexSettingsUpdate).
  141    153   
    pub fn builder() -> crate::types::builders::GlobalTableGlobalSecondaryIndexSettingsUpdateBuilder {
  142    154   
        crate::types::builders::GlobalTableGlobalSecondaryIndexSettingsUpdateBuilder::default()
  143    155   
    }
  144    156   
}
  145    157   
  146    158   
/// A builder for [`GlobalTableGlobalSecondaryIndexSettingsUpdate`](crate::types::GlobalTableGlobalSecondaryIndexSettingsUpdate).
  147    159   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  148    160   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_item_collection_metrics.rs

@@ -8,8 +173,178 @@
   28     28   
    "com.amazonaws.dynamodb",
   29     29   
    "ItemCollectionMetrics",
   30     30   
);
   31     31   
static ITEMCOLLECTIONMETRICS_MEMBER_ITEM_COLLECTION_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static(
   33     33   
        "com.amazonaws.dynamodb#ItemCollectionMetrics$ItemCollectionKey",
   34     34   
        "com.amazonaws.dynamodb",
   35     35   
        "ItemCollectionMetrics",
   36     36   
    ),
   37     37   
    ::aws_smithy_schema::ShapeType::Map,
   38         -
    "item_collection_key",
          38  +
    "ItemCollectionKey",
   39     39   
    0,
   40     40   
);
   41     41   
static ITEMCOLLECTIONMETRICS_MEMBER_SIZE_ESTIMATE_RANGE_GB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   42     42   
    ::aws_smithy_schema::ShapeId::from_static(
   43     43   
        "com.amazonaws.dynamodb#ItemCollectionMetrics$SizeEstimateRangeGB",
   44     44   
        "com.amazonaws.dynamodb",
   45     45   
        "ItemCollectionMetrics",
   46     46   
    ),
   47     47   
    ::aws_smithy_schema::ShapeType::List,
   48         -
    "size_estimate_range_gb",
          48  +
    "SizeEstimateRangeGB",
   49     49   
    1,
   50     50   
);
   51     51   
static ITEMCOLLECTIONMETRICS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   52     52   
    ITEMCOLLECTIONMETRICS_SCHEMA_ID,
   53     53   
    ::aws_smithy_schema::ShapeType::Structure,
   54     54   
    &[
   55     55   
        &ITEMCOLLECTIONMETRICS_MEMBER_ITEM_COLLECTION_KEY,
   56     56   
        &ITEMCOLLECTIONMETRICS_MEMBER_SIZE_ESTIMATE_RANGE_GB,
   57     57   
    ],
   58     58   
);
   59     59   
impl ItemCollectionMetrics {
   60     60   
    /// The schema for this shape.
   61     61   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ITEMCOLLECTIONMETRICS_SCHEMA;
   62     62   
}
   63     63   
impl ::aws_smithy_schema::serde::SerializableStruct for ItemCollectionMetrics {
   64     64   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   65     65   
    fn serialize_members(
   66     66   
        &self,
   67     67   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   68     68   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   69     69   
        if let Some(ref val) = self.item_collection_key {
   70     70   
            ser.write_map(
   71     71   
                &ITEMCOLLECTIONMETRICS_MEMBER_ITEM_COLLECTION_KEY,
   72     72   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   73     73   
                    for (key, value) in val {
   74     74   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   75         -
                        todo!("schema: unsupported map value type");
          75  +
                        ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
   76     76   
                    }
   77     77   
                    Ok(())
   78     78   
                },
   79     79   
            )?;
   80     80   
        }
   81     81   
        if let Some(ref val) = self.size_estimate_range_gb {
   82     82   
            ser.write_list(
   83     83   
                &ITEMCOLLECTIONMETRICS_MEMBER_SIZE_ESTIMATE_RANGE_GB,
   84     84   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   85     85   
                    for item in val {
   86     86   
                        ser.write_double(&aws_smithy_schema::prelude::DOUBLE, *item)?;
   87     87   
                    }
   88     88   
                    Ok(())
   89     89   
                },
   90     90   
            )?;
   91     91   
        }
   92     92   
        Ok(())
   93     93   
    }
   94     94   
}
   95     95   
impl ItemCollectionMetrics {
   96     96   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   97         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   98         -
        deserializer: &mut D,
          97  +
    pub fn deserialize(
          98  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   99     99   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  100    100   
        #[allow(unused_variables, unused_mut)]
  101    101   
        let mut builder = Self::builder();
  102    102   
        #[allow(
  103    103   
            unused_variables,
  104    104   
            unreachable_code,
  105    105   
            clippy::single_match,
  106    106   
            clippy::match_single_binding,
  107    107   
            clippy::diverging_sub_expression
  108    108   
        )]
  109         -
        deserializer.read_struct(&ITEMCOLLECTIONMETRICS_SCHEMA, (), |_, member, deser| {
         109  +
        deserializer.read_struct(&ITEMCOLLECTIONMETRICS_SCHEMA, &mut |member, deser| {
  110    110   
            match member.member_index() {
  111    111   
                Some(0) => {
  112    112   
                    builder.item_collection_key = Some({
  113         -
                        let container = if let Some(cap) = deser.container_size() {
  114         -
                            std::collections::HashMap::with_capacity(cap)
  115         -
                        } else {
  116         -
                            std::collections::HashMap::new()
  117         -
                        };
  118         -
                        deser.read_map(member, container, |mut map, key, deser| {
  119         -
                            map.insert(key, todo!("deserialize nested aggregate"));
  120         -
                            Ok(map)
  121         -
                        })?
         113  +
                        let mut container = std::collections::HashMap::new();
         114  +
                        deser.read_map(member, &mut |key, deser| {
         115  +
                            container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
         116  +
                            Ok(())
         117  +
                        })?;
         118  +
                        container
  122    119   
                    });
  123    120   
                }
  124    121   
                Some(1) => {
  125    122   
                    builder.size_estimate_range_gb = Some({
  126         -
                        let container = if let Some(cap) = deser.container_size() {
  127         -
                            Vec::with_capacity(cap)
  128         -
                        } else {
  129         -
                            Vec::new()
  130         -
                        };
  131         -
                        deser.read_list(member, container, |mut list, deser| {
  132         -
                            list.push(deser.read_double(member)?);
  133         -
                            Ok(list)
  134         -
                        })?
         123  +
                        let mut container = Vec::new();
         124  +
                        deser.read_list(member, &mut |deser| {
         125  +
                            container.push(deser.read_double(member)?);
         126  +
                            Ok(())
         127  +
                        })?;
         128  +
                        container
  135    129   
                    });
  136    130   
                }
  137    131   
                _ => {}
  138    132   
            }
  139    133   
            Ok(())
  140    134   
        })?;
  141    135   
        Ok(builder.build())
  142    136   
    }
  143    137   
}
         138  +
impl ItemCollectionMetrics {
         139  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         140  +
    pub fn deserialize_with_response(
         141  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         142  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         143  +
        _status: u16,
         144  +
        _body: &[u8],
         145  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         146  +
        Self::deserialize(deserializer)
         147  +
    }
         148  +
}
  144    149   
impl ItemCollectionMetrics {
  145    150   
    /// Creates a new builder-style object to manufacture [`ItemCollectionMetrics`](crate::types::ItemCollectionMetrics).
  146    151   
    pub fn builder() -> crate::types::builders::ItemCollectionMetricsBuilder {
  147    152   
        crate::types::builders::ItemCollectionMetricsBuilder::default()
  148    153   
    }
  149    154   
}
  150    155   
  151    156   
/// A builder for [`ItemCollectionMetrics`](crate::types::ItemCollectionMetrics).
  152    157   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  153    158   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_item_response.rs

@@ -1,1 +116,124 @@
   11     11   
    /// <p>Map of attribute data consisting of the data type and attribute value.</p>
   12     12   
    pub fn item(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>> {
   13     13   
        self.item.as_ref()
   14     14   
    }
   15     15   
}
   16     16   
static ITEMRESPONSE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#ItemResponse", "com.amazonaws.dynamodb", "ItemResponse");
   18     18   
static ITEMRESPONSE_MEMBER_ITEM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#ItemResponse$Item", "com.amazonaws.dynamodb", "ItemResponse"),
   20     20   
    ::aws_smithy_schema::ShapeType::Map,
   21         -
    "item",
          21  +
    "Item",
   22     22   
    0,
   23     23   
);
   24     24   
static ITEMRESPONSE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   25     25   
    ITEMRESPONSE_SCHEMA_ID,
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    &[&ITEMRESPONSE_MEMBER_ITEM],
   28     28   
);
   29     29   
impl ItemResponse {
   30     30   
    /// The schema for this shape.
   31     31   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ITEMRESPONSE_SCHEMA;
   32     32   
}
   33     33   
impl ::aws_smithy_schema::serde::SerializableStruct for ItemResponse {
   34     34   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   35     35   
    fn serialize_members(
   36     36   
        &self,
   37     37   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   38     38   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   39     39   
        if let Some(ref val) = self.item {
   40     40   
            ser.write_map(&ITEMRESPONSE_MEMBER_ITEM, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   41     41   
                for (key, value) in val {
   42     42   
                    ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   43         -
                    todo!("schema: unsupported map value type");
          43  +
                    ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
   44     44   
                }
   45     45   
                Ok(())
   46     46   
            })?;
   47     47   
        }
   48     48   
        Ok(())
   49     49   
    }
   50     50   
}
   51     51   
impl ItemResponse {
   52     52   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   53         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   54         -
        deserializer: &mut D,
          53  +
    pub fn deserialize(
          54  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   55     55   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   56     56   
        #[allow(unused_variables, unused_mut)]
   57     57   
        let mut builder = Self::builder();
   58     58   
        #[allow(
   59     59   
            unused_variables,
   60     60   
            unreachable_code,
   61     61   
            clippy::single_match,
   62     62   
            clippy::match_single_binding,
   63     63   
            clippy::diverging_sub_expression
   64     64   
        )]
   65         -
        deserializer.read_struct(&ITEMRESPONSE_SCHEMA, (), |_, member, deser| {
          65  +
        deserializer.read_struct(&ITEMRESPONSE_SCHEMA, &mut |member, deser| {
   66     66   
            match member.member_index() {
   67     67   
                Some(0) => {
   68     68   
                    builder.item = Some({
   69         -
                        let container = if let Some(cap) = deser.container_size() {
   70         -
                            std::collections::HashMap::with_capacity(cap)
   71         -
                        } else {
   72         -
                            std::collections::HashMap::new()
   73         -
                        };
   74         -
                        deser.read_map(member, container, |mut map, key, deser| {
   75         -
                            map.insert(key, todo!("deserialize nested aggregate"));
   76         -
                            Ok(map)
   77         -
                        })?
          69  +
                        let mut container = std::collections::HashMap::new();
          70  +
                        deser.read_map(member, &mut |key, deser| {
          71  +
                            container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
          72  +
                            Ok(())
          73  +
                        })?;
          74  +
                        container
   78     75   
                    });
   79     76   
                }
   80     77   
                _ => {}
   81     78   
            }
   82     79   
            Ok(())
   83     80   
        })?;
   84     81   
        Ok(builder.build())
   85     82   
    }
   86     83   
}
          84  +
impl ItemResponse {
          85  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          86  +
    pub fn deserialize_with_response(
          87  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          88  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          89  +
        _status: u16,
          90  +
        _body: &[u8],
          91  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          92  +
        Self::deserialize(deserializer)
          93  +
    }
          94  +
}
   87     95   
impl ItemResponse {
   88     96   
    /// Creates a new builder-style object to manufacture [`ItemResponse`](crate::types::ItemResponse).
   89     97   
    pub fn builder() -> crate::types::builders::ItemResponseBuilder {
   90     98   
        crate::types::builders::ItemResponseBuilder::default()
   91     99   
    }
   92    100   
}
   93    101   
   94    102   
/// A builder for [`ItemResponse`](crate::types::ItemResponse).
   95    103   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   96    104   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_key_schema_element.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_keys_and_attributes.rs

@@ -79,79 +317,323 @@
   99     99   
}
  100    100   
static KEYSANDATTRIBUTES_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  101    101   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#KeysAndAttributes", "com.amazonaws.dynamodb", "KeysAndAttributes");
  102    102   
static KEYSANDATTRIBUTES_MEMBER_KEYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static(
  104    104   
        "com.amazonaws.dynamodb#KeysAndAttributes$Keys",
  105    105   
        "com.amazonaws.dynamodb",
  106    106   
        "KeysAndAttributes",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::List,
  109         -
    "keys",
         109  +
    "Keys",
  110    110   
    0,
  111    111   
);
  112    112   
static KEYSANDATTRIBUTES_MEMBER_ATTRIBUTES_TO_GET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.dynamodb#KeysAndAttributes$AttributesToGet",
  115    115   
        "com.amazonaws.dynamodb",
  116    116   
        "KeysAndAttributes",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::List,
  119         -
    "attributes_to_get",
         119  +
    "AttributesToGet",
  120    120   
    1,
  121    121   
);
  122    122   
static KEYSANDATTRIBUTES_MEMBER_CONSISTENT_READ: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  123    123   
    ::aws_smithy_schema::ShapeId::from_static(
  124    124   
        "com.amazonaws.dynamodb#KeysAndAttributes$ConsistentRead",
  125    125   
        "com.amazonaws.dynamodb",
  126    126   
        "KeysAndAttributes",
  127    127   
    ),
  128    128   
    ::aws_smithy_schema::ShapeType::Boolean,
  129         -
    "consistent_read",
         129  +
    "ConsistentRead",
  130    130   
    2,
  131    131   
);
  132    132   
static KEYSANDATTRIBUTES_MEMBER_PROJECTION_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  133    133   
    ::aws_smithy_schema::ShapeId::from_static(
  134    134   
        "com.amazonaws.dynamodb#KeysAndAttributes$ProjectionExpression",
  135    135   
        "com.amazonaws.dynamodb",
  136    136   
        "KeysAndAttributes",
  137    137   
    ),
  138    138   
    ::aws_smithy_schema::ShapeType::String,
  139         -
    "projection_expression",
         139  +
    "ProjectionExpression",
  140    140   
    3,
  141    141   
);
  142    142   
static KEYSANDATTRIBUTES_MEMBER_EXPRESSION_ATTRIBUTE_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  143    143   
    ::aws_smithy_schema::ShapeId::from_static(
  144    144   
        "com.amazonaws.dynamodb#KeysAndAttributes$ExpressionAttributeNames",
  145    145   
        "com.amazonaws.dynamodb",
  146    146   
        "KeysAndAttributes",
  147    147   
    ),
  148    148   
    ::aws_smithy_schema::ShapeType::Map,
  149         -
    "expression_attribute_names",
         149  +
    "ExpressionAttributeNames",
  150    150   
    4,
  151    151   
);
  152    152   
static KEYSANDATTRIBUTES_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  153    153   
    KEYSANDATTRIBUTES_SCHEMA_ID,
  154    154   
    ::aws_smithy_schema::ShapeType::Structure,
  155    155   
    &[
  156    156   
        &KEYSANDATTRIBUTES_MEMBER_KEYS,
  157    157   
        &KEYSANDATTRIBUTES_MEMBER_ATTRIBUTES_TO_GET,
  158    158   
        &KEYSANDATTRIBUTES_MEMBER_CONSISTENT_READ,
  159    159   
        &KEYSANDATTRIBUTES_MEMBER_PROJECTION_EXPRESSION,
  160    160   
        &KEYSANDATTRIBUTES_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
  161    161   
    ],
  162    162   
);
  163    163   
impl KeysAndAttributes {
  164    164   
    /// The schema for this shape.
  165    165   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &KEYSANDATTRIBUTES_SCHEMA;
  166    166   
}
  167    167   
impl ::aws_smithy_schema::serde::SerializableStruct for KeysAndAttributes {
  168    168   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  169    169   
    fn serialize_members(
  170    170   
        &self,
  171    171   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  172    172   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  173    173   
        {
  174    174   
            let val = &self.keys;
  175    175   
  176    176   
            ser.write_list(
  177    177   
                &KEYSANDATTRIBUTES_MEMBER_KEYS,
  178    178   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  179    179   
                    for item in val {
  180         -
                        todo!("schema: unsupported list element type");
         180  +
                        ser.write_map(
         181  +
                            &::aws_smithy_schema::prelude::DOCUMENT,
         182  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         183  +
                                for (key, value) in item {
         184  +
                                    ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
         185  +
                                    ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
         186  +
                                }
         187  +
                                Ok(())
         188  +
                            },
         189  +
                        )?;
  181    190   
                    }
  182    191   
                    Ok(())
  183    192   
                },
  184    193   
            )?;
  185    194   
        }
  186    195   
        if let Some(ref val) = self.attributes_to_get {
  187    196   
            ser.write_list(
  188    197   
                &KEYSANDATTRIBUTES_MEMBER_ATTRIBUTES_TO_GET,
  189    198   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  190    199   
                    for item in val {
  191    200   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  192    201   
                    }
  193    202   
                    Ok(())
  194    203   
                },
  195    204   
            )?;
  196    205   
        }
  197    206   
        if let Some(ref val) = self.consistent_read {
  198    207   
            ser.write_boolean(&KEYSANDATTRIBUTES_MEMBER_CONSISTENT_READ, *val)?;
  199    208   
        }
  200    209   
        if let Some(ref val) = self.projection_expression {
  201    210   
            ser.write_string(&KEYSANDATTRIBUTES_MEMBER_PROJECTION_EXPRESSION, val)?;
  202    211   
        }
  203    212   
        if let Some(ref val) = self.expression_attribute_names {
  204    213   
            ser.write_map(
  205    214   
                &KEYSANDATTRIBUTES_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
  206    215   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  207    216   
                    for (key, value) in val {
  208    217   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  209    218   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
  210    219   
                    }
  211    220   
                    Ok(())
  212    221   
                },
  213    222   
            )?;
  214    223   
        }
  215    224   
        Ok(())
  216    225   
    }
  217    226   
}
  218    227   
impl KeysAndAttributes {
  219    228   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  220         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  221         -
        deserializer: &mut D,
         229  +
    pub fn deserialize(
         230  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  222    231   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  223    232   
        #[allow(unused_variables, unused_mut)]
  224    233   
        let mut builder = Self::builder();
  225    234   
        #[allow(
  226    235   
            unused_variables,
  227    236   
            unreachable_code,
  228    237   
            clippy::single_match,
  229    238   
            clippy::match_single_binding,
  230    239   
            clippy::diverging_sub_expression
  231    240   
        )]
  232         -
        deserializer.read_struct(&KEYSANDATTRIBUTES_SCHEMA, (), |_, member, deser| {
         241  +
        deserializer.read_struct(&KEYSANDATTRIBUTES_SCHEMA, &mut |member, deser| {
  233    242   
            match member.member_index() {
  234    243   
                Some(0) => {
  235    244   
                    builder.keys = Some({
  236         -
                        let container = if let Some(cap) = deser.container_size() {
  237         -
                            Vec::with_capacity(cap)
  238         -
                        } else {
  239         -
                            Vec::new()
  240         -
                        };
  241         -
                        deser.read_list(member, container, |mut list, deser| {
  242         -
                            list.push(todo!("deserialize nested aggregate"));
  243         -
                            Ok(list)
  244         -
                        })?
         245  +
                        let mut container = Vec::new();
         246  +
                        deser.read_list(member, &mut |deser| {
         247  +
                            container.push({
         248  +
                                let mut map = ::std::collections::HashMap::new();
         249  +
                                deser.read_map(member, &mut |key, deser| {
         250  +
                                    let value = crate::types::AttributeValue::deserialize(deser)?;
         251  +
                                    map.insert(key, value);
         252  +
                                    Ok(())
         253  +
                                })?;
         254  +
                                map
         255  +
                            });
         256  +
                            Ok(())
         257  +
                        })?;
         258  +
                        container
  245    259   
                    });
  246    260   
                }
  247    261   
                Some(1) => {
  248         -
                    builder.attributes_to_get = Some({
  249         -
                        let container = if let Some(cap) = deser.container_size() {
  250         -
                            Vec::with_capacity(cap)
  251         -
                        } else {
  252         -
                            Vec::new()
  253         -
                        };
  254         -
                        deser.read_list(member, container, |mut list, deser| {
  255         -
                            list.push(deser.read_string(member)?);
  256         -
                            Ok(list)
  257         -
                        })?
  258         -
                    });
         262  +
                    builder.attributes_to_get = Some(deser.read_string_list(member)?);
  259    263   
                }
  260    264   
                Some(2) => {
  261    265   
                    builder.consistent_read = Some(deser.read_boolean(member)?);
  262    266   
                }
  263    267   
                Some(3) => {
  264    268   
                    builder.projection_expression = Some(deser.read_string(member)?);
  265    269   
                }
  266    270   
                Some(4) => {
  267         -
                    builder.expression_attribute_names = Some({
  268         -
                        let container = if let Some(cap) = deser.container_size() {
  269         -
                            std::collections::HashMap::with_capacity(cap)
  270         -
                        } else {
  271         -
                            std::collections::HashMap::new()
  272         -
                        };
  273         -
                        deser.read_map(member, container, |mut map, key, deser| {
  274         -
                            map.insert(key, deser.read_string(member)?);
  275         -
                            Ok(map)
  276         -
                        })?
  277         -
                    });
         271  +
                    builder.expression_attribute_names = Some(deser.read_string_string_map(member)?);
  278    272   
                }
  279    273   
                _ => {}
  280    274   
            }
  281    275   
            Ok(())
  282    276   
        })?;
         277  +
        builder.keys = builder.keys.or(Some(Vec::new()));
  283    278   
        builder
  284    279   
            .build()
  285    280   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  286    281   
    }
  287    282   
}
         283  +
impl KeysAndAttributes {
         284  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         285  +
    pub fn deserialize_with_response(
         286  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         287  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         288  +
        _status: u16,
         289  +
        _body: &[u8],
         290  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         291  +
        Self::deserialize(deserializer)
         292  +
    }
         293  +
}
  288    294   
impl KeysAndAttributes {
  289    295   
    /// Creates a new builder-style object to manufacture [`KeysAndAttributes`](crate::types::KeysAndAttributes).
  290    296   
    pub fn builder() -> crate::types::builders::KeysAndAttributesBuilder {
  291    297   
        crate::types::builders::KeysAndAttributesBuilder::default()
  292    298   
    }
  293    299   
}
  294    300   
  295    301   
/// A builder for [`KeysAndAttributes`](crate::types::KeysAndAttributes).
  296    302   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  297    303   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_kinesis_data_stream_destination.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_local_secondary_index.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_local_secondary_index_description.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_local_secondary_index_info.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_parameterized_statement.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_point_in_time_recovery_description.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_point_in_time_recovery_specification.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_projection.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_provisioned_throughput.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_provisioned_throughput_description.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_provisioned_throughput_override.rs

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