Client Test

Client Test

rev. 32b1b3c3761061baed26023be3219639e42d7d12

Files changed:

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

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

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

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

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

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

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

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

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

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

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

@@ -78,78 +208,208 @@
   98     98   
    "com.amazonaws.dynamodb",
   99     99   
    "ReplicaDescription",
  100    100   
);
  101    101   
static REPLICADESCRIPTION_MEMBER_REGION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.dynamodb#ReplicaDescription$RegionName",
  104    104   
        "com.amazonaws.dynamodb",
  105    105   
        "ReplicaDescription",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "region_name",
         108  +
    "RegionName",
  109    109   
    0,
  110    110   
);
  111    111   
static REPLICADESCRIPTION_MEMBER_REPLICA_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static(
  113    113   
        "com.amazonaws.dynamodb#ReplicaDescription$ReplicaStatus",
  114    114   
        "com.amazonaws.dynamodb",
  115    115   
        "ReplicaDescription",
  116    116   
    ),
  117    117   
    ::aws_smithy_schema::ShapeType::String,
  118         -
    "replica_status",
         118  +
    "ReplicaStatus",
  119    119   
    1,
  120    120   
);
  121    121   
static REPLICADESCRIPTION_MEMBER_REPLICA_STATUS_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static(
  123    123   
        "com.amazonaws.dynamodb#ReplicaDescription$ReplicaStatusDescription",
  124    124   
        "com.amazonaws.dynamodb",
  125    125   
        "ReplicaDescription",
  126    126   
    ),
  127    127   
    ::aws_smithy_schema::ShapeType::String,
  128         -
    "replica_status_description",
         128  +
    "ReplicaStatusDescription",
  129    129   
    2,
  130    130   
);
  131    131   
static REPLICADESCRIPTION_MEMBER_REPLICA_STATUS_PERCENT_PROGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  132    132   
    ::aws_smithy_schema::ShapeId::from_static(
  133    133   
        "com.amazonaws.dynamodb#ReplicaDescription$ReplicaStatusPercentProgress",
  134    134   
        "com.amazonaws.dynamodb",
  135    135   
        "ReplicaDescription",
  136    136   
    ),
  137    137   
    ::aws_smithy_schema::ShapeType::String,
  138         -
    "replica_status_percent_progress",
         138  +
    "ReplicaStatusPercentProgress",
  139    139   
    3,
  140    140   
);
  141    141   
static REPLICADESCRIPTION_MEMBER_KMS_MASTER_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  142    142   
    ::aws_smithy_schema::ShapeId::from_static(
  143    143   
        "com.amazonaws.dynamodb#ReplicaDescription$KMSMasterKeyId",
  144    144   
        "com.amazonaws.dynamodb",
  145    145   
        "ReplicaDescription",
  146    146   
    ),
  147    147   
    ::aws_smithy_schema::ShapeType::String,
  148         -
    "kms_master_key_id",
         148  +
    "KMSMasterKeyId",
  149    149   
    4,
  150    150   
);
  151    151   
static REPLICADESCRIPTION_MEMBER_PROVISIONED_THROUGHPUT_OVERRIDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  152    152   
    ::aws_smithy_schema::ShapeId::from_static(
  153    153   
        "com.amazonaws.dynamodb#ReplicaDescription$ProvisionedThroughputOverride",
  154    154   
        "com.amazonaws.dynamodb",
  155    155   
        "ReplicaDescription",
  156    156   
    ),
  157    157   
    ::aws_smithy_schema::ShapeType::Structure,
  158         -
    "provisioned_throughput_override",
         158  +
    "ProvisionedThroughputOverride",
  159    159   
    5,
  160    160   
);
  161    161   
static REPLICADESCRIPTION_MEMBER_GLOBAL_SECONDARY_INDEXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  162    162   
    ::aws_smithy_schema::ShapeId::from_static(
  163    163   
        "com.amazonaws.dynamodb#ReplicaDescription$GlobalSecondaryIndexes",
  164    164   
        "com.amazonaws.dynamodb",
  165    165   
        "ReplicaDescription",
  166    166   
    ),
  167    167   
    ::aws_smithy_schema::ShapeType::List,
  168         -
    "global_secondary_indexes",
         168  +
    "GlobalSecondaryIndexes",
  169    169   
    6,
  170    170   
);
  171    171   
static REPLICADESCRIPTION_MEMBER_REPLICA_INACCESSIBLE_DATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  172    172   
    ::aws_smithy_schema::ShapeId::from_static(
  173    173   
        "com.amazonaws.dynamodb#ReplicaDescription$ReplicaInaccessibleDateTime",
  174    174   
        "com.amazonaws.dynamodb",
  175    175   
        "ReplicaDescription",
  176    176   
    ),
  177    177   
    ::aws_smithy_schema::ShapeType::Timestamp,
  178         -
    "replica_inaccessible_date_time",
         178  +
    "ReplicaInaccessibleDateTime",
  179    179   
    7,
  180    180   
);
  181    181   
static REPLICADESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  182    182   
    REPLICADESCRIPTION_SCHEMA_ID,
  183    183   
    ::aws_smithy_schema::ShapeType::Structure,
  184    184   
    &[
  185    185   
        &REPLICADESCRIPTION_MEMBER_REGION_NAME,
  186    186   
        &REPLICADESCRIPTION_MEMBER_REPLICA_STATUS,
  187    187   
        &REPLICADESCRIPTION_MEMBER_REPLICA_STATUS_DESCRIPTION,
  188    188   
        &REPLICADESCRIPTION_MEMBER_REPLICA_STATUS_PERCENT_PROGRESS,
@@ -212,212 +326,334 @@
  232    232   
            )?;
  233    233   
        }
  234    234   
        if let Some(ref val) = self.replica_inaccessible_date_time {
  235    235   
            ser.write_timestamp(&REPLICADESCRIPTION_MEMBER_REPLICA_INACCESSIBLE_DATE_TIME, val)?;
  236    236   
        }
  237    237   
        Ok(())
  238    238   
    }
  239    239   
}
  240    240   
impl ReplicaDescription {
  241    241   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  242         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  243         -
        deserializer: &mut D,
         242  +
    pub fn deserialize(
         243  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  244    244   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  245    245   
        #[allow(unused_variables, unused_mut)]
  246    246   
        let mut builder = Self::builder();
  247    247   
        #[allow(
  248    248   
            unused_variables,
  249    249   
            unreachable_code,
  250    250   
            clippy::single_match,
  251    251   
            clippy::match_single_binding,
  252    252   
            clippy::diverging_sub_expression
  253    253   
        )]
  254         -
        deserializer.read_struct(&REPLICADESCRIPTION_SCHEMA, (), |_, member, deser| {
         254  +
        deserializer.read_struct(&REPLICADESCRIPTION_SCHEMA, &mut |member, deser| {
  255    255   
            match member.member_index() {
  256    256   
                Some(0) => {
  257    257   
                    builder.region_name = Some(deser.read_string(member)?);
  258    258   
                }
  259    259   
                Some(1) => {
  260    260   
                    builder.replica_status = Some(crate::types::ReplicaStatus::from(deser.read_string(member)?.as_str()));
  261    261   
                }
  262    262   
                Some(2) => {
  263    263   
                    builder.replica_status_description = Some(deser.read_string(member)?);
  264    264   
                }
  265    265   
                Some(3) => {
  266    266   
                    builder.replica_status_percent_progress = Some(deser.read_string(member)?);
  267    267   
                }
  268    268   
                Some(4) => {
  269    269   
                    builder.kms_master_key_id = Some(deser.read_string(member)?);
  270    270   
                }
  271    271   
                Some(5) => {
  272    272   
                    builder.provisioned_throughput_override = Some(crate::types::ProvisionedThroughputOverride::deserialize(deser)?);
  273    273   
                }
  274    274   
                Some(6) => {
  275    275   
                    builder.global_secondary_indexes = Some({
  276         -
                        let container = if let Some(cap) = deser.container_size() {
  277         -
                            Vec::with_capacity(cap)
  278         -
                        } else {
  279         -
                            Vec::new()
  280         -
                        };
  281         -
                        deser.read_list(member, container, |mut list, deser| {
  282         -
                            list.push(crate::types::ReplicaGlobalSecondaryIndexDescription::deserialize(deser)?);
  283         -
                            Ok(list)
  284         -
                        })?
         276  +
                        let mut container = Vec::new();
         277  +
                        deser.read_list(member, &mut |deser| {
         278  +
                            container.push(crate::types::ReplicaGlobalSecondaryIndexDescription::deserialize(deser)?);
         279  +
                            Ok(())
         280  +
                        })?;
         281  +
                        container
  285    282   
                    });
  286    283   
                }
  287    284   
                Some(7) => {
  288    285   
                    builder.replica_inaccessible_date_time = Some(deser.read_timestamp(member)?);
  289    286   
                }
  290    287   
                _ => {}
  291    288   
            }
  292    289   
            Ok(())
  293    290   
        })?;
  294    291   
        Ok(builder.build())
  295    292   
    }
  296    293   
}
         294  +
impl ReplicaDescription {
         295  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         296  +
    pub fn deserialize_with_response(
         297  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         298  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         299  +
        _status: u16,
         300  +
        _body: &[u8],
         301  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         302  +
        Self::deserialize(deserializer)
         303  +
    }
         304  +
}
  297    305   
impl ReplicaDescription {
  298    306   
    /// Creates a new builder-style object to manufacture [`ReplicaDescription`](crate::types::ReplicaDescription).
  299    307   
    pub fn builder() -> crate::types::builders::ReplicaDescriptionBuilder {
  300    308   
        crate::types::builders::ReplicaDescriptionBuilder::default()
  301    309   
    }
  302    310   
}
  303    311   
  304    312   
/// A builder for [`ReplicaDescription`](crate::types::ReplicaDescription).
  305    313   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  306    314   
#[non_exhaustive]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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