Client Test

Client Test

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

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

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

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

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

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

@@ -1,1 +120,129 @@
   11     11   
    /// <p>A map of attribute name to attribute values, representing the primary key of the item to delete. All of the table's primary key attributes must be specified, and their data types must match those of the table's key schema.</p>
   12     12   
    pub fn key(&self) -> &::std::collections::HashMap<::std::string::String, crate::types::AttributeValue> {
   13     13   
        &self.key
   14     14   
    }
   15     15   
}
   16     16   
static DELETEREQUEST_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#DeleteRequest", "com.amazonaws.dynamodb", "DeleteRequest");
   18     18   
static DELETEREQUEST_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#DeleteRequest$Key", "com.amazonaws.dynamodb", "DeleteRequest"),
   20     20   
    ::aws_smithy_schema::ShapeType::Map,
   21         -
    "key",
          21  +
    "Key",
   22     22   
    0,
   23     23   
);
   24     24   
static DELETEREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   25     25   
    DELETEREQUEST_SCHEMA_ID,
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    &[&DELETEREQUEST_MEMBER_KEY],
   28     28   
);
   29     29   
impl DeleteRequest {
   30     30   
    /// The schema for this shape.
   31     31   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEREQUEST_SCHEMA;
   32     32   
}
   33     33   
impl ::aws_smithy_schema::serde::SerializableStruct for DeleteRequest {
   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.key;
   41     41   
   42     42   
            ser.write_map(&DELETEREQUEST_MEMBER_KEY, &|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 DeleteRequest {
   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(&DELETEREQUEST_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&DELETEREQUEST_SCHEMA, &mut |member, deser| {
   68     68   
            match member.member_index() {
   69     69   
                Some(0) => {
   70     70   
                    builder.key = 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.key = builder.key.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 DeleteRequest {
          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 DeleteRequest {
   92    101   
    /// Creates a new builder-style object to manufacture [`DeleteRequest`](crate::types::DeleteRequest).
   93    102   
    pub fn builder() -> crate::types::builders::DeleteRequestBuilder {
   94    103   
        crate::types::builders::DeleteRequestBuilder::default()
   95    104   
    }
   96    105   
}
   97    106   
   98    107   
/// A builder for [`DeleteRequest`](crate::types::DeleteRequest).
   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/_endpoint.rs

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

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

@@ -175,175 +358,363 @@
  195    195   
    "com.amazonaws.dynamodb",
  196    196   
    "ExpectedAttributeValue",
  197    197   
);
  198    198   
static EXPECTEDATTRIBUTEVALUE_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  199    199   
    ::aws_smithy_schema::ShapeId::from_static(
  200    200   
        "com.amazonaws.dynamodb#ExpectedAttributeValue$Value",
  201    201   
        "com.amazonaws.dynamodb",
  202    202   
        "ExpectedAttributeValue",
  203    203   
    ),
  204    204   
    ::aws_smithy_schema::ShapeType::Union,
  205         -
    "value",
         205  +
    "Value",
  206    206   
    0,
  207    207   
);
  208    208   
static EXPECTEDATTRIBUTEVALUE_MEMBER_EXISTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  209    209   
    ::aws_smithy_schema::ShapeId::from_static(
  210    210   
        "com.amazonaws.dynamodb#ExpectedAttributeValue$Exists",
  211    211   
        "com.amazonaws.dynamodb",
  212    212   
        "ExpectedAttributeValue",
  213    213   
    ),
  214    214   
    ::aws_smithy_schema::ShapeType::Boolean,
  215         -
    "exists",
         215  +
    "Exists",
  216    216   
    1,
  217    217   
);
  218    218   
static EXPECTEDATTRIBUTEVALUE_MEMBER_COMPARISON_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  219    219   
    ::aws_smithy_schema::ShapeId::from_static(
  220    220   
        "com.amazonaws.dynamodb#ExpectedAttributeValue$ComparisonOperator",
  221    221   
        "com.amazonaws.dynamodb",
  222    222   
        "ExpectedAttributeValue",
  223    223   
    ),
  224    224   
    ::aws_smithy_schema::ShapeType::String,
  225         -
    "comparison_operator",
         225  +
    "ComparisonOperator",
  226    226   
    2,
  227    227   
);
  228    228   
static EXPECTEDATTRIBUTEVALUE_MEMBER_ATTRIBUTE_VALUE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  229    229   
    ::aws_smithy_schema::ShapeId::from_static(
  230    230   
        "com.amazonaws.dynamodb#ExpectedAttributeValue$AttributeValueList",
  231    231   
        "com.amazonaws.dynamodb",
  232    232   
        "ExpectedAttributeValue",
  233    233   
    ),
  234    234   
    ::aws_smithy_schema::ShapeType::List,
  235         -
    "attribute_value_list",
         235  +
    "AttributeValueList",
  236    236   
    3,
  237    237   
);
  238    238   
static EXPECTEDATTRIBUTEVALUE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  239    239   
    EXPECTEDATTRIBUTEVALUE_SCHEMA_ID,
  240    240   
    ::aws_smithy_schema::ShapeType::Structure,
  241    241   
    &[
  242    242   
        &EXPECTEDATTRIBUTEVALUE_MEMBER_VALUE,
  243    243   
        &EXPECTEDATTRIBUTEVALUE_MEMBER_EXISTS,
  244    244   
        &EXPECTEDATTRIBUTEVALUE_MEMBER_COMPARISON_OPERATOR,
  245    245   
        &EXPECTEDATTRIBUTEVALUE_MEMBER_ATTRIBUTE_VALUE_LIST,
  246    246   
    ],
  247    247   
);
  248    248   
impl ExpectedAttributeValue {
  249    249   
    /// The schema for this shape.
  250    250   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXPECTEDATTRIBUTEVALUE_SCHEMA;
  251    251   
}
  252    252   
impl ::aws_smithy_schema::serde::SerializableStruct for ExpectedAttributeValue {
  253    253   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  254    254   
    fn serialize_members(
  255    255   
        &self,
  256    256   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  257    257   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  258    258   
        if let Some(ref val) = self.value {
  259         -
            ser.write_null(&EXPECTEDATTRIBUTEVALUE_MEMBER_VALUE)?;
         259  +
            ser.write_struct(&EXPECTEDATTRIBUTEVALUE_MEMBER_VALUE, val)?;
  260    260   
        }
  261    261   
        if let Some(ref val) = self.exists {
  262    262   
            ser.write_boolean(&EXPECTEDATTRIBUTEVALUE_MEMBER_EXISTS, *val)?;
  263    263   
        }
  264    264   
        if let Some(ref val) = self.comparison_operator {
  265    265   
            ser.write_string(&EXPECTEDATTRIBUTEVALUE_MEMBER_COMPARISON_OPERATOR, val.as_str())?;
  266    266   
        }
  267    267   
        if let Some(ref val) = self.attribute_value_list {
  268    268   
            ser.write_list(
  269    269   
                &EXPECTEDATTRIBUTEVALUE_MEMBER_ATTRIBUTE_VALUE_LIST,
  270    270   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  271    271   
                    for item in val {
  272         -
                        todo!("schema: unsupported list element type");
         272  +
                        ser.write_struct(crate::types::AttributeValue::SCHEMA, item)?;
  273    273   
                    }
  274    274   
                    Ok(())
  275    275   
                },
  276    276   
            )?;
  277    277   
        }
  278    278   
        Ok(())
  279    279   
    }
  280    280   
}
  281    281   
impl ExpectedAttributeValue {
  282    282   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  283         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  284         -
        deserializer: &mut D,
         283  +
    pub fn deserialize(
         284  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  285    285   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  286    286   
        #[allow(unused_variables, unused_mut)]
  287    287   
        let mut builder = Self::builder();
  288    288   
        #[allow(
  289    289   
            unused_variables,
  290    290   
            unreachable_code,
  291    291   
            clippy::single_match,
  292    292   
            clippy::match_single_binding,
  293    293   
            clippy::diverging_sub_expression
  294    294   
        )]
  295         -
        deserializer.read_struct(&EXPECTEDATTRIBUTEVALUE_SCHEMA, (), |_, member, deser| {
         295  +
        deserializer.read_struct(&EXPECTEDATTRIBUTEVALUE_SCHEMA, &mut |member, deser| {
  296    296   
            match member.member_index() {
  297    297   
                Some(0) => {
  298         -
                    builder.value = Some({
  299         -
                        let _ = member;
  300         -
                        todo!("deserialize aggregate")
  301         -
                    });
         298  +
                    builder.value = Some(crate::types::AttributeValue::deserialize(deser)?);
  302    299   
                }
  303    300   
                Some(1) => {
  304    301   
                    builder.exists = Some(deser.read_boolean(member)?);
  305    302   
                }
  306    303   
                Some(2) => {
  307    304   
                    builder.comparison_operator = Some(crate::types::ComparisonOperator::from(deser.read_string(member)?.as_str()));
  308    305   
                }
  309    306   
                Some(3) => {
  310    307   
                    builder.attribute_value_list = Some({
  311         -
                        let container = if let Some(cap) = deser.container_size() {
  312         -
                            Vec::with_capacity(cap)
  313         -
                        } else {
  314         -
                            Vec::new()
  315         -
                        };
  316         -
                        deser.read_list(member, container, |mut list, deser| {
  317         -
                            list.push(todo!("deserialize nested aggregate"));
  318         -
                            Ok(list)
  319         -
                        })?
         308  +
                        let mut container = Vec::new();
         309  +
                        deser.read_list(member, &mut |deser| {
         310  +
                            container.push(crate::types::AttributeValue::deserialize(deser)?);
         311  +
                            Ok(())
         312  +
                        })?;
         313  +
                        container
  320    314   
                    });
  321    315   
                }
  322    316   
                _ => {}
  323    317   
            }
  324    318   
            Ok(())
  325    319   
        })?;
  326    320   
        Ok(builder.build())
  327    321   
    }
  328    322   
}
         323  +
impl ExpectedAttributeValue {
         324  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         325  +
    pub fn deserialize_with_response(
         326  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         327  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         328  +
        _status: u16,
         329  +
        _body: &[u8],
         330  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         331  +
        Self::deserialize(deserializer)
         332  +
    }
         333  +
}
  329    334   
impl ExpectedAttributeValue {
  330    335   
    /// Creates a new builder-style object to manufacture [`ExpectedAttributeValue`](crate::types::ExpectedAttributeValue).
  331    336   
    pub fn builder() -> crate::types::builders::ExpectedAttributeValueBuilder {
  332    337   
        crate::types::builders::ExpectedAttributeValueBuilder::default()
  333    338   
    }
  334    339   
}
  335    340   
  336    341   
/// A builder for [`ExpectedAttributeValue`](crate::types::ExpectedAttributeValue).
  337    342   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  338    343   
#[non_exhaustive]

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

@@ -115,115 +355,355 @@
  135    135   
}
  136    136   
static EXPORTDESCRIPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  137    137   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#ExportDescription", "com.amazonaws.dynamodb", "ExportDescription");
  138    138   
static EXPORTDESCRIPTION_MEMBER_EXPORT_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  139    139   
    ::aws_smithy_schema::ShapeId::from_static(
  140    140   
        "com.amazonaws.dynamodb#ExportDescription$ExportArn",
  141    141   
        "com.amazonaws.dynamodb",
  142    142   
        "ExportDescription",
  143    143   
    ),
  144    144   
    ::aws_smithy_schema::ShapeType::String,
  145         -
    "export_arn",
         145  +
    "ExportArn",
  146    146   
    0,
  147    147   
);
  148    148   
static EXPORTDESCRIPTION_MEMBER_EXPORT_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  149    149   
    ::aws_smithy_schema::ShapeId::from_static(
  150    150   
        "com.amazonaws.dynamodb#ExportDescription$ExportStatus",
  151    151   
        "com.amazonaws.dynamodb",
  152    152   
        "ExportDescription",
  153    153   
    ),
  154    154   
    ::aws_smithy_schema::ShapeType::String,
  155         -
    "export_status",
         155  +
    "ExportStatus",
  156    156   
    1,
  157    157   
);
  158    158   
static EXPORTDESCRIPTION_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  159    159   
    ::aws_smithy_schema::ShapeId::from_static(
  160    160   
        "com.amazonaws.dynamodb#ExportDescription$StartTime",
  161    161   
        "com.amazonaws.dynamodb",
  162    162   
        "ExportDescription",
  163    163   
    ),
  164    164   
    ::aws_smithy_schema::ShapeType::Timestamp,
  165         -
    "start_time",
         165  +
    "StartTime",
  166    166   
    2,
  167    167   
);
  168    168   
static EXPORTDESCRIPTION_MEMBER_END_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  169    169   
    ::aws_smithy_schema::ShapeId::from_static(
  170    170   
        "com.amazonaws.dynamodb#ExportDescription$EndTime",
  171    171   
        "com.amazonaws.dynamodb",
  172    172   
        "ExportDescription",
  173    173   
    ),
  174    174   
    ::aws_smithy_schema::ShapeType::Timestamp,
  175         -
    "end_time",
         175  +
    "EndTime",
  176    176   
    3,
  177    177   
);
  178    178   
static EXPORTDESCRIPTION_MEMBER_EXPORT_MANIFEST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static(
  180    180   
        "com.amazonaws.dynamodb#ExportDescription$ExportManifest",
  181    181   
        "com.amazonaws.dynamodb",
  182    182   
        "ExportDescription",
  183    183   
    ),
  184    184   
    ::aws_smithy_schema::ShapeType::String,
  185         -
    "export_manifest",
         185  +
    "ExportManifest",
  186    186   
    4,
  187    187   
);
  188    188   
static EXPORTDESCRIPTION_MEMBER_TABLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  189    189   
    ::aws_smithy_schema::ShapeId::from_static(
  190    190   
        "com.amazonaws.dynamodb#ExportDescription$TableArn",
  191    191   
        "com.amazonaws.dynamodb",
  192    192   
        "ExportDescription",
  193    193   
    ),
  194    194   
    ::aws_smithy_schema::ShapeType::String,
  195         -
    "table_arn",
         195  +
    "TableArn",
  196    196   
    5,
  197    197   
);
  198    198   
static EXPORTDESCRIPTION_MEMBER_TABLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  199    199   
    ::aws_smithy_schema::ShapeId::from_static(
  200    200   
        "com.amazonaws.dynamodb#ExportDescription$TableId",
  201    201   
        "com.amazonaws.dynamodb",
  202    202   
        "ExportDescription",
  203    203   
    ),
  204    204   
    ::aws_smithy_schema::ShapeType::String,
  205         -
    "table_id",
         205  +
    "TableId",
  206    206   
    6,
  207    207   
);
  208    208   
static EXPORTDESCRIPTION_MEMBER_EXPORT_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  209    209   
    ::aws_smithy_schema::ShapeId::from_static(
  210    210   
        "com.amazonaws.dynamodb#ExportDescription$ExportTime",
  211    211   
        "com.amazonaws.dynamodb",
  212    212   
        "ExportDescription",
  213    213   
    ),
  214    214   
    ::aws_smithy_schema::ShapeType::Timestamp,
  215         -
    "export_time",
         215  +
    "ExportTime",
  216    216   
    7,
  217    217   
);
  218    218   
static EXPORTDESCRIPTION_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  219    219   
    ::aws_smithy_schema::ShapeId::from_static(
  220    220   
        "com.amazonaws.dynamodb#ExportDescription$ClientToken",
  221    221   
        "com.amazonaws.dynamodb",
  222    222   
        "ExportDescription",
  223    223   
    ),
  224    224   
    ::aws_smithy_schema::ShapeType::String,
  225         -
    "client_token",
         225  +
    "ClientToken",
  226    226   
    8,
  227    227   
);
  228    228   
static EXPORTDESCRIPTION_MEMBER_S3_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  229    229   
    ::aws_smithy_schema::ShapeId::from_static(
  230    230   
        "com.amazonaws.dynamodb#ExportDescription$S3Bucket",
  231    231   
        "com.amazonaws.dynamodb",
  232    232   
        "ExportDescription",
  233    233   
    ),
  234    234   
    ::aws_smithy_schema::ShapeType::String,
  235         -
    "s3_bucket",
         235  +
    "S3Bucket",
  236    236   
    9,
  237    237   
);
  238    238   
static EXPORTDESCRIPTION_MEMBER_S3_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  239    239   
    ::aws_smithy_schema::ShapeId::from_static(
  240    240   
        "com.amazonaws.dynamodb#ExportDescription$S3BucketOwner",
  241    241   
        "com.amazonaws.dynamodb",
  242    242   
        "ExportDescription",
  243    243   
    ),
  244    244   
    ::aws_smithy_schema::ShapeType::String,
  245         -
    "s3_bucket_owner",
         245  +
    "S3BucketOwner",
  246    246   
    10,
  247    247   
);
  248    248   
static EXPORTDESCRIPTION_MEMBER_S3_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  249    249   
    ::aws_smithy_schema::ShapeId::from_static(
  250    250   
        "com.amazonaws.dynamodb#ExportDescription$S3Prefix",
  251    251   
        "com.amazonaws.dynamodb",
  252    252   
        "ExportDescription",
  253    253   
    ),
  254    254   
    ::aws_smithy_schema::ShapeType::String,
  255         -
    "s3_prefix",
         255  +
    "S3Prefix",
  256    256   
    11,
  257    257   
);
  258    258   
static EXPORTDESCRIPTION_MEMBER_S3_SSE_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  259    259   
    ::aws_smithy_schema::ShapeId::from_static(
  260    260   
        "com.amazonaws.dynamodb#ExportDescription$S3SseAlgorithm",
  261    261   
        "com.amazonaws.dynamodb",
  262    262   
        "ExportDescription",
  263    263   
    ),
  264    264   
    ::aws_smithy_schema::ShapeType::String,
  265         -
    "s3_sse_algorithm",
         265  +
    "S3SseAlgorithm",
  266    266   
    12,
  267    267   
);
  268    268   
static EXPORTDESCRIPTION_MEMBER_S3_SSE_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  269    269   
    ::aws_smithy_schema::ShapeId::from_static(
  270    270   
        "com.amazonaws.dynamodb#ExportDescription$S3SseKmsKeyId",
  271    271   
        "com.amazonaws.dynamodb",
  272    272   
        "ExportDescription",
  273    273   
    ),
  274    274   
    ::aws_smithy_schema::ShapeType::String,
  275         -
    "s3_sse_kms_key_id",
         275  +
    "S3SseKmsKeyId",
  276    276   
    13,
  277    277   
);
  278    278   
static EXPORTDESCRIPTION_MEMBER_FAILURE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  279    279   
    ::aws_smithy_schema::ShapeId::from_static(
  280    280   
        "com.amazonaws.dynamodb#ExportDescription$FailureCode",
  281    281   
        "com.amazonaws.dynamodb",
  282    282   
        "ExportDescription",
  283    283   
    ),
  284    284   
    ::aws_smithy_schema::ShapeType::String,
  285         -
    "failure_code",
         285  +
    "FailureCode",
  286    286   
    14,
  287    287   
);
  288    288   
static EXPORTDESCRIPTION_MEMBER_FAILURE_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  289    289   
    ::aws_smithy_schema::ShapeId::from_static(
  290    290   
        "com.amazonaws.dynamodb#ExportDescription$FailureMessage",
  291    291   
        "com.amazonaws.dynamodb",
  292    292   
        "ExportDescription",
  293    293   
    ),
  294    294   
    ::aws_smithy_schema::ShapeType::String,
  295         -
    "failure_message",
         295  +
    "FailureMessage",
  296    296   
    15,
  297    297   
);
  298    298   
static EXPORTDESCRIPTION_MEMBER_EXPORT_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  299    299   
    ::aws_smithy_schema::ShapeId::from_static(
  300    300   
        "com.amazonaws.dynamodb#ExportDescription$ExportFormat",
  301    301   
        "com.amazonaws.dynamodb",
  302    302   
        "ExportDescription",
  303    303   
    ),
  304    304   
    ::aws_smithy_schema::ShapeType::String,
  305         -
    "export_format",
         305  +
    "ExportFormat",
  306    306   
    16,
  307    307   
);
  308    308   
static EXPORTDESCRIPTION_MEMBER_BILLED_SIZE_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  309    309   
    ::aws_smithy_schema::ShapeId::from_static(
  310    310   
        "com.amazonaws.dynamodb#ExportDescription$BilledSizeBytes",
  311    311   
        "com.amazonaws.dynamodb",
  312    312   
        "ExportDescription",
  313    313   
    ),
  314    314   
    ::aws_smithy_schema::ShapeType::Long,
  315         -
    "billed_size_bytes",
         315  +
    "BilledSizeBytes",
  316    316   
    17,
  317    317   
);
  318    318   
static EXPORTDESCRIPTION_MEMBER_ITEM_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  319    319   
    ::aws_smithy_schema::ShapeId::from_static(
  320    320   
        "com.amazonaws.dynamodb#ExportDescription$ItemCount",
  321    321   
        "com.amazonaws.dynamodb",
  322    322   
        "ExportDescription",
  323    323   
    ),
  324    324   
    ::aws_smithy_schema::ShapeType::Long,
  325         -
    "item_count",
         325  +
    "ItemCount",
  326    326   
    18,
  327    327   
);
  328    328   
static EXPORTDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  329    329   
    EXPORTDESCRIPTION_SCHEMA_ID,
  330    330   
    ::aws_smithy_schema::ShapeType::Structure,
  331    331   
    &[
  332    332   
        &EXPORTDESCRIPTION_MEMBER_EXPORT_ARN,
  333    333   
        &EXPORTDESCRIPTION_MEMBER_EXPORT_STATUS,
  334    334   
        &EXPORTDESCRIPTION_MEMBER_START_TIME,
  335    335   
        &EXPORTDESCRIPTION_MEMBER_END_TIME,
@@ -395,395 +467,467 @@
  415    415   
            ser.write_long(&EXPORTDESCRIPTION_MEMBER_BILLED_SIZE_BYTES, *val)?;
  416    416   
        }
  417    417   
        if let Some(ref val) = self.item_count {
  418    418   
            ser.write_long(&EXPORTDESCRIPTION_MEMBER_ITEM_COUNT, *val)?;
  419    419   
        }
  420    420   
        Ok(())
  421    421   
    }
  422    422   
}
  423    423   
impl ExportDescription {
  424    424   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  425         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  426         -
        deserializer: &mut D,
         425  +
    pub fn deserialize(
         426  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  427    427   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  428    428   
        #[allow(unused_variables, unused_mut)]
  429    429   
        let mut builder = Self::builder();
  430    430   
        #[allow(
  431    431   
            unused_variables,
  432    432   
            unreachable_code,
  433    433   
            clippy::single_match,
  434    434   
            clippy::match_single_binding,
  435    435   
            clippy::diverging_sub_expression
  436    436   
        )]
  437         -
        deserializer.read_struct(&EXPORTDESCRIPTION_SCHEMA, (), |_, member, deser| {
         437  +
        deserializer.read_struct(&EXPORTDESCRIPTION_SCHEMA, &mut |member, deser| {
  438    438   
            match member.member_index() {
  439    439   
                Some(0) => {
  440    440   
                    builder.export_arn = Some(deser.read_string(member)?);
  441    441   
                }
  442    442   
                Some(1) => {
  443    443   
                    builder.export_status = Some(crate::types::ExportStatus::from(deser.read_string(member)?.as_str()));
  444    444   
                }
  445    445   
                Some(2) => {
  446    446   
                    builder.start_time = Some(deser.read_timestamp(member)?);
  447    447   
                }
@@ -473,473 +532,543 @@
  493    493   
                Some(18) => {
  494    494   
                    builder.item_count = Some(deser.read_long(member)?);
  495    495   
                }
  496    496   
                _ => {}
  497    497   
            }
  498    498   
            Ok(())
  499    499   
        })?;
  500    500   
        Ok(builder.build())
  501    501   
    }
  502    502   
}
         503  +
impl ExportDescription {
         504  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         505  +
    pub fn deserialize_with_response(
         506  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         507  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         508  +
        _status: u16,
         509  +
        _body: &[u8],
         510  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         511  +
        Self::deserialize(deserializer)
         512  +
    }
         513  +
}
  503    514   
impl ExportDescription {
  504    515   
    /// Creates a new builder-style object to manufacture [`ExportDescription`](crate::types::ExportDescription).
  505    516   
    pub fn builder() -> crate::types::builders::ExportDescriptionBuilder {
  506    517   
        crate::types::builders::ExportDescriptionBuilder::default()
  507    518   
    }
  508    519   
}
  509    520   
  510    521   
/// A builder for [`ExportDescription`](crate::types::ExportDescription).
  511    522   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  512    523   
#[non_exhaustive]

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

@@ -1,1 +126,137 @@
   21     21   
}
   22     22   
static EXPORTSUMMARY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#ExportSummary", "com.amazonaws.dynamodb", "ExportSummary");
   24     24   
static EXPORTSUMMARY_MEMBER_EXPORT_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static(
   26     26   
        "com.amazonaws.dynamodb#ExportSummary$ExportArn",
   27     27   
        "com.amazonaws.dynamodb",
   28     28   
        "ExportSummary",
   29     29   
    ),
   30     30   
    ::aws_smithy_schema::ShapeType::String,
   31         -
    "export_arn",
          31  +
    "ExportArn",
   32     32   
    0,
   33     33   
);
   34     34   
static EXPORTSUMMARY_MEMBER_EXPORT_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   35     35   
    ::aws_smithy_schema::ShapeId::from_static(
   36     36   
        "com.amazonaws.dynamodb#ExportSummary$ExportStatus",
   37     37   
        "com.amazonaws.dynamodb",
   38     38   
        "ExportSummary",
   39     39   
    ),
   40     40   
    ::aws_smithy_schema::ShapeType::String,
   41         -
    "export_status",
          41  +
    "ExportStatus",
   42     42   
    1,
   43     43   
);
   44     44   
static EXPORTSUMMARY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   45     45   
    EXPORTSUMMARY_SCHEMA_ID,
   46     46   
    ::aws_smithy_schema::ShapeType::Structure,
   47     47   
    &[&EXPORTSUMMARY_MEMBER_EXPORT_ARN, &EXPORTSUMMARY_MEMBER_EXPORT_STATUS],
   48     48   
);
   49     49   
impl ExportSummary {
   50     50   
    /// The schema for this shape.
   51     51   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXPORTSUMMARY_SCHEMA;
   52     52   
}
   53     53   
impl ::aws_smithy_schema::serde::SerializableStruct for ExportSummary {
   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.export_arn {
   60     60   
            ser.write_string(&EXPORTSUMMARY_MEMBER_EXPORT_ARN, val)?;
   61     61   
        }
   62     62   
        if let Some(ref val) = self.export_status {
   63     63   
            ser.write_string(&EXPORTSUMMARY_MEMBER_EXPORT_STATUS, val.as_str())?;
   64     64   
        }
   65     65   
        Ok(())
   66     66   
    }
   67     67   
}
   68     68   
impl ExportSummary {
   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(&EXPORTSUMMARY_SCHEMA, (), |_, member, deser| {
          82  +
        deserializer.read_struct(&EXPORTSUMMARY_SCHEMA, &mut |member, deser| {
   83     83   
            match member.member_index() {
   84     84   
                Some(0) => {
   85     85   
                    builder.export_arn = Some(deser.read_string(member)?);
   86     86   
                }
   87     87   
                Some(1) => {
   88     88   
                    builder.export_status = Some(crate::types::ExportStatus::from(deser.read_string(member)?.as_str()));
   89     89   
                }
   90     90   
                _ => {}
   91     91   
            }
   92     92   
            Ok(())
   93     93   
        })?;
   94     94   
        Ok(builder.build())
   95     95   
    }
   96     96   
}
          97  +
impl ExportSummary {
          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 ExportSummary {
   98    109   
    /// Creates a new builder-style object to manufacture [`ExportSummary`](crate::types::ExportSummary).
   99    110   
    pub fn builder() -> crate::types::builders::ExportSummaryBuilder {
  100    111   
        crate::types::builders::ExportSummaryBuilder::default()
  101    112   
    }
  102    113   
}
  103    114   
  104    115   
/// A builder for [`ExportSummary`](crate::types::ExportSummary).
  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/_failure_exception.rs

@@ -1,1 +126,137 @@
   21     21   
}
   22     22   
static FAILUREEXCEPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#FailureException", "com.amazonaws.dynamodb", "FailureException");
   24     24   
static FAILUREEXCEPTION_MEMBER_EXCEPTION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static(
   26     26   
        "com.amazonaws.dynamodb#FailureException$ExceptionName",
   27     27   
        "com.amazonaws.dynamodb",
   28     28   
        "FailureException",
   29     29   
    ),
   30     30   
    ::aws_smithy_schema::ShapeType::String,
   31         -
    "exception_name",
          31  +
    "ExceptionName",
   32     32   
    0,
   33     33   
);
   34     34   
static FAILUREEXCEPTION_MEMBER_EXCEPTION_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   35     35   
    ::aws_smithy_schema::ShapeId::from_static(
   36     36   
        "com.amazonaws.dynamodb#FailureException$ExceptionDescription",
   37     37   
        "com.amazonaws.dynamodb",
   38     38   
        "FailureException",
   39     39   
    ),
   40     40   
    ::aws_smithy_schema::ShapeType::String,
   41         -
    "exception_description",
          41  +
    "ExceptionDescription",
   42     42   
    1,
   43     43   
);
   44     44   
static FAILUREEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   45     45   
    FAILUREEXCEPTION_SCHEMA_ID,
   46     46   
    ::aws_smithy_schema::ShapeType::Structure,
   47     47   
    &[&FAILUREEXCEPTION_MEMBER_EXCEPTION_NAME, &FAILUREEXCEPTION_MEMBER_EXCEPTION_DESCRIPTION],
   48     48   
);
   49     49   
impl FailureException {
   50     50   
    /// The schema for this shape.
   51     51   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FAILUREEXCEPTION_SCHEMA;
   52     52   
}
   53     53   
impl ::aws_smithy_schema::serde::SerializableStruct for FailureException {
   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.exception_name {
   60     60   
            ser.write_string(&FAILUREEXCEPTION_MEMBER_EXCEPTION_NAME, val)?;
   61     61   
        }
   62     62   
        if let Some(ref val) = self.exception_description {
   63     63   
            ser.write_string(&FAILUREEXCEPTION_MEMBER_EXCEPTION_DESCRIPTION, val)?;
   64     64   
        }
   65     65   
        Ok(())
   66     66   
    }
   67     67   
}
   68     68   
impl FailureException {
   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(&FAILUREEXCEPTION_SCHEMA, (), |_, member, deser| {
          82  +
        deserializer.read_struct(&FAILUREEXCEPTION_SCHEMA, &mut |member, deser| {
   83     83   
            match member.member_index() {
   84     84   
                Some(0) => {
   85     85   
                    builder.exception_name = Some(deser.read_string(member)?);
   86     86   
                }
   87     87   
                Some(1) => {
   88     88   
                    builder.exception_description = Some(deser.read_string(member)?);
   89     89   
                }
   90     90   
                _ => {}
   91     91   
            }
   92     92   
            Ok(())
   93     93   
        })?;
   94     94   
        Ok(builder.build())
   95     95   
    }
   96     96   
}
          97  +
impl FailureException {
          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 FailureException {
   98    109   
    /// Creates a new builder-style object to manufacture [`FailureException`](crate::types::FailureException).
   99    110   
    pub fn builder() -> crate::types::builders::FailureExceptionBuilder {
  100    111   
        crate::types::builders::FailureExceptionBuilder::default()
  101    112   
    }
  102    113   
}
  103    114   
  104    115   
/// A builder for [`FailureException`](crate::types::FailureException).
  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/_get.rs

@@ -10,10 +200,200 @@
   30     30   
    /// <p>One or more substitution tokens for attribute names in the ProjectionExpression parameter.</p>
   31     31   
    pub fn expression_attribute_names(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
   32     32   
        self.expression_attribute_names.as_ref()
   33     33   
    }
   34     34   
}
   35     35   
static GET_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   36     36   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Get", "com.amazonaws.dynamodb", "Get");
   37     37   
static GET_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Get$Key", "com.amazonaws.dynamodb", "Get"),
   39     39   
    ::aws_smithy_schema::ShapeType::Map,
   40         -
    "key",
          40  +
    "Key",
   41     41   
    0,
   42     42   
);
   43     43   
static GET_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Get$TableName", "com.amazonaws.dynamodb", "Get"),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "table_name",
          46  +
    "TableName",
   47     47   
    1,
   48     48   
);
   49     49   
static GET_MEMBER_PROJECTION_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Get$ProjectionExpression", "com.amazonaws.dynamodb", "Get"),
   51     51   
    ::aws_smithy_schema::ShapeType::String,
   52         -
    "projection_expression",
          52  +
    "ProjectionExpression",
   53     53   
    2,
   54     54   
);
   55     55   
static GET_MEMBER_EXPRESSION_ATTRIBUTE_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#Get$ExpressionAttributeNames", "com.amazonaws.dynamodb", "Get"),
   57     57   
    ::aws_smithy_schema::ShapeType::Map,
   58         -
    "expression_attribute_names",
          58  +
    "ExpressionAttributeNames",
   59     59   
    3,
   60     60   
);
   61     61   
static GET_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   62     62   
    GET_SCHEMA_ID,
   63     63   
    ::aws_smithy_schema::ShapeType::Structure,
   64     64   
    &[
   65     65   
        &GET_MEMBER_KEY,
   66     66   
        &GET_MEMBER_TABLE_NAME,
   67     67   
        &GET_MEMBER_PROJECTION_EXPRESSION,
   68     68   
        &GET_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
   69     69   
    ],
   70     70   
);
   71     71   
impl Get {
   72     72   
    /// The schema for this shape.
   73     73   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GET_SCHEMA;
   74     74   
}
   75     75   
impl ::aws_smithy_schema::serde::SerializableStruct for Get {
   76     76   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   77     77   
    fn serialize_members(
   78     78   
        &self,
   79     79   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   80     80   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   81     81   
        {
   82     82   
            let val = &self.key;
   83     83   
   84     84   
            ser.write_map(&GET_MEMBER_KEY, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   85     85   
                for (key, value) in val {
   86     86   
                    ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   87         -
                    todo!("schema: unsupported map value type");
          87  +
                    ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
   88     88   
                }
   89     89   
                Ok(())
   90     90   
            })?;
   91     91   
        }
   92     92   
        {
   93     93   
            let val = &self.table_name;
   94     94   
            ser.write_string(&GET_MEMBER_TABLE_NAME, val)?;
   95     95   
        }
   96     96   
        if let Some(ref val) = self.projection_expression {
   97     97   
            ser.write_string(&GET_MEMBER_PROJECTION_EXPRESSION, val)?;
   98     98   
        }
   99     99   
        if let Some(ref val) = self.expression_attribute_names {
  100    100   
            ser.write_map(
  101    101   
                &GET_MEMBER_EXPRESSION_ATTRIBUTE_NAMES,
  102    102   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  103    103   
                    for (key, value) in val {
  104    104   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  105    105   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
  106    106   
                    }
  107    107   
                    Ok(())
  108    108   
                },
  109    109   
            )?;
  110    110   
        }
  111    111   
        Ok(())
  112    112   
    }
  113    113   
}
  114    114   
impl Get {
  115    115   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  116         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  117         -
        deserializer: &mut D,
         116  +
    pub fn deserialize(
         117  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  118    118   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  119    119   
        #[allow(unused_variables, unused_mut)]
  120    120   
        let mut builder = Self::builder();
  121    121   
        #[allow(
  122    122   
            unused_variables,
  123    123   
            unreachable_code,
  124    124   
            clippy::single_match,
  125    125   
            clippy::match_single_binding,
  126    126   
            clippy::diverging_sub_expression
  127    127   
        )]
  128         -
        deserializer.read_struct(&GET_SCHEMA, (), |_, member, deser| {
         128  +
        deserializer.read_struct(&GET_SCHEMA, &mut |member, deser| {
  129    129   
            match member.member_index() {
  130    130   
                Some(0) => {
  131    131   
                    builder.key = Some({
  132         -
                        let container = if let Some(cap) = deser.container_size() {
  133         -
                            std::collections::HashMap::with_capacity(cap)
  134         -
                        } else {
  135         -
                            std::collections::HashMap::new()
  136         -
                        };
  137         -
                        deser.read_map(member, container, |mut map, key, deser| {
  138         -
                            map.insert(key, todo!("deserialize nested aggregate"));
  139         -
                            Ok(map)
  140         -
                        })?
         132  +
                        let mut container = std::collections::HashMap::new();
         133  +
                        deser.read_map(member, &mut |key, deser| {
         134  +
                            container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
         135  +
                            Ok(())
         136  +
                        })?;
         137  +
                        container
  141    138   
                    });
  142    139   
                }
  143    140   
                Some(1) => {
  144    141   
                    builder.table_name = Some(deser.read_string(member)?);
  145    142   
                }
  146    143   
                Some(2) => {
  147    144   
                    builder.projection_expression = Some(deser.read_string(member)?);
  148    145   
                }
  149    146   
                Some(3) => {
  150         -
                    builder.expression_attribute_names = Some({
  151         -
                        let container = if let Some(cap) = deser.container_size() {
  152         -
                            std::collections::HashMap::with_capacity(cap)
  153         -
                        } else {
  154         -
                            std::collections::HashMap::new()
  155         -
                        };
  156         -
                        deser.read_map(member, container, |mut map, key, deser| {
  157         -
                            map.insert(key, deser.read_string(member)?);
  158         -
                            Ok(map)
  159         -
                        })?
  160         -
                    });
         147  +
                    builder.expression_attribute_names = Some(deser.read_string_string_map(member)?);
  161    148   
                }
  162    149   
                _ => {}
  163    150   
            }
  164    151   
            Ok(())
  165    152   
        })?;
         153  +
        builder.key = builder.key.or(Some(::std::collections::HashMap::new()));
         154  +
        builder.table_name = builder.table_name.or(Some(String::new()));
  166    155   
        builder
  167    156   
            .build()
  168    157   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  169    158   
    }
  170    159   
}
         160  +
impl Get {
         161  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         162  +
    pub fn deserialize_with_response(
         163  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         164  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         165  +
        _status: u16,
         166  +
        _body: &[u8],
         167  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         168  +
        Self::deserialize(deserializer)
         169  +
    }
         170  +
}
  171    171   
impl Get {
  172    172   
    /// Creates a new builder-style object to manufacture [`Get`](crate::types::Get).
  173    173   
    pub fn builder() -> crate::types::builders::GetBuilder {
  174    174   
        crate::types::builders::GetBuilder::default()
  175    175   
    }
  176    176   
}
  177    177   
  178    178   
/// A builder for [`Get`](crate::types::Get).
  179    179   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  180    180   
#[non_exhaustive]

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

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

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

@@ -4,4 +136,147 @@
   24     24   
    "com.amazonaws.dynamodb",
   25     25   
    "GlobalSecondaryIndexAutoScalingUpdate",
   26     26   
);
   27     27   
static GLOBALSECONDARYINDEXAUTOSCALINGUPDATE_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#GlobalSecondaryIndexAutoScalingUpdate$IndexName",
   30     30   
        "com.amazonaws.dynamodb",
   31     31   
        "GlobalSecondaryIndexAutoScalingUpdate",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "index_name",
          34  +
    "IndexName",
   35     35   
    0,
   36     36   
);
   37     37   
static GLOBALSECONDARYINDEXAUTOSCALINGUPDATE_MEMBER_PROVISIONED_WRITE_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#GlobalSecondaryIndexAutoScalingUpdate$ProvisionedWriteCapacityAutoScalingUpdate",
   41     41   
            "com.amazonaws.dynamodb",
   42     42   
            "GlobalSecondaryIndexAutoScalingUpdate",
   43     43   
        ),
   44     44   
        ::aws_smithy_schema::ShapeType::Structure,
   45         -
        "provisioned_write_capacity_auto_scaling_update",
          45  +
        "ProvisionedWriteCapacityAutoScalingUpdate",
   46     46   
        1,
   47     47   
    );
   48     48   
static GLOBALSECONDARYINDEXAUTOSCALINGUPDATE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    GLOBALSECONDARYINDEXAUTOSCALINGUPDATE_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[
   52     52   
        &GLOBALSECONDARYINDEXAUTOSCALINGUPDATE_MEMBER_INDEX_NAME,
   53     53   
        &GLOBALSECONDARYINDEXAUTOSCALINGUPDATE_MEMBER_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_UPDATE,
   54     54   
    ],
   55     55   
);
   56     56   
impl GlobalSecondaryIndexAutoScalingUpdate {
   57     57   
    /// The schema for this shape.
   58     58   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GLOBALSECONDARYINDEXAUTOSCALINGUPDATE_SCHEMA;
   59     59   
}
   60     60   
impl ::aws_smithy_schema::serde::SerializableStruct for GlobalSecondaryIndexAutoScalingUpdate {
   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(&GLOBALSECONDARYINDEXAUTOSCALINGUPDATE_MEMBER_INDEX_NAME, val)?;
   68     68   
        }
   69     69   
        if let Some(ref val) = self.provisioned_write_capacity_auto_scaling_update {
   70     70   
            ser.write_struct(
   71     71   
                &GLOBALSECONDARYINDEXAUTOSCALINGUPDATE_MEMBER_PROVISIONED_WRITE_CAPACITY_AUTO_SCALING_UPDATE,
   72     72   
                val,
   73     73   
            )?;
   74     74   
        }
   75     75   
        Ok(())
   76     76   
    }
   77     77   
}
   78     78   
impl GlobalSecondaryIndexAutoScalingUpdate {
   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(&GLOBALSECONDARYINDEXAUTOSCALINGUPDATE_SCHEMA, (), |_, member, deser| {
          92  +
        deserializer.read_struct(&GLOBALSECONDARYINDEXAUTOSCALINGUPDATE_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_write_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 GlobalSecondaryIndexAutoScalingUpdate {
         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 GlobalSecondaryIndexAutoScalingUpdate {
  108    119   
    /// Creates a new builder-style object to manufacture [`GlobalSecondaryIndexAutoScalingUpdate`](crate::types::GlobalSecondaryIndexAutoScalingUpdate).
  109    120   
    pub fn builder() -> crate::types::builders::GlobalSecondaryIndexAutoScalingUpdateBuilder {
  110    121   
        crate::types::builders::GlobalSecondaryIndexAutoScalingUpdateBuilder::default()
  111    122   
    }
  112    123   
}
  113    124   
  114    125   
/// A builder for [`GlobalSecondaryIndexAutoScalingUpdate`](crate::types::GlobalSecondaryIndexAutoScalingUpdate).
  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/_global_secondary_index_description.rs

@@ -94,94 +234,234 @@
  114    114   
    "com.amazonaws.dynamodb",
  115    115   
    "GlobalSecondaryIndexDescription",
  116    116   
);
  117    117   
static GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexDescription$IndexName",
  120    120   
        "com.amazonaws.dynamodb",
  121    121   
        "GlobalSecondaryIndexDescription",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::String,
  124         -
    "index_name",
         124  +
    "IndexName",
  125    125   
    0,
  126    126   
);
  127    127   
static GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_KEY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static(
  129    129   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexDescription$KeySchema",
  130    130   
        "com.amazonaws.dynamodb",
  131    131   
        "GlobalSecondaryIndexDescription",
  132    132   
    ),
  133    133   
    ::aws_smithy_schema::ShapeType::List,
  134         -
    "key_schema",
         134  +
    "KeySchema",
  135    135   
    1,
  136    136   
);
  137    137   
static GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_PROJECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static(
  139    139   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexDescription$Projection",
  140    140   
        "com.amazonaws.dynamodb",
  141    141   
        "GlobalSecondaryIndexDescription",
  142    142   
    ),
  143    143   
    ::aws_smithy_schema::ShapeType::Structure,
  144         -
    "projection",
         144  +
    "Projection",
  145    145   
    2,
  146    146   
);
  147    147   
static GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  148    148   
    ::aws_smithy_schema::ShapeId::from_static(
  149    149   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexDescription$IndexStatus",
  150    150   
        "com.amazonaws.dynamodb",
  151    151   
        "GlobalSecondaryIndexDescription",
  152    152   
    ),
  153    153   
    ::aws_smithy_schema::ShapeType::String,
  154         -
    "index_status",
         154  +
    "IndexStatus",
  155    155   
    3,
  156    156   
);
  157    157   
static GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_BACKFILLING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  158    158   
    ::aws_smithy_schema::ShapeId::from_static(
  159    159   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexDescription$Backfilling",
  160    160   
        "com.amazonaws.dynamodb",
  161    161   
        "GlobalSecondaryIndexDescription",
  162    162   
    ),
  163    163   
    ::aws_smithy_schema::ShapeType::Boolean,
  164         -
    "backfilling",
         164  +
    "Backfilling",
  165    165   
    4,
  166    166   
);
  167    167   
static GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_PROVISIONED_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  168    168   
    ::aws_smithy_schema::ShapeId::from_static(
  169    169   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexDescription$ProvisionedThroughput",
  170    170   
        "com.amazonaws.dynamodb",
  171    171   
        "GlobalSecondaryIndexDescription",
  172    172   
    ),
  173    173   
    ::aws_smithy_schema::ShapeType::Structure,
  174         -
    "provisioned_throughput",
         174  +
    "ProvisionedThroughput",
  175    175   
    5,
  176    176   
);
  177    177   
static GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_SIZE_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  178    178   
    ::aws_smithy_schema::ShapeId::from_static(
  179    179   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexDescription$IndexSizeBytes",
  180    180   
        "com.amazonaws.dynamodb",
  181    181   
        "GlobalSecondaryIndexDescription",
  182    182   
    ),
  183    183   
    ::aws_smithy_schema::ShapeType::Long,
  184         -
    "index_size_bytes",
         184  +
    "IndexSizeBytes",
  185    185   
    6,
  186    186   
);
  187    187   
static GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_ITEM_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  188    188   
    ::aws_smithy_schema::ShapeId::from_static(
  189    189   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexDescription$ItemCount",
  190    190   
        "com.amazonaws.dynamodb",
  191    191   
        "GlobalSecondaryIndexDescription",
  192    192   
    ),
  193    193   
    ::aws_smithy_schema::ShapeType::Long,
  194         -
    "item_count",
         194  +
    "ItemCount",
  195    195   
    7,
  196    196   
);
  197    197   
static GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  198    198   
    ::aws_smithy_schema::ShapeId::from_static(
  199    199   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexDescription$IndexArn",
  200    200   
        "com.amazonaws.dynamodb",
  201    201   
        "GlobalSecondaryIndexDescription",
  202    202   
    ),
  203    203   
    ::aws_smithy_schema::ShapeType::String,
  204         -
    "index_arn",
         204  +
    "IndexArn",
  205    205   
    8,
  206    206   
);
  207    207   
static GLOBALSECONDARYINDEXDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  208    208   
    GLOBALSECONDARYINDEXDESCRIPTION_SCHEMA_ID,
  209    209   
    ::aws_smithy_schema::ShapeType::Structure,
  210    210   
    &[
  211    211   
        &GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_NAME,
  212    212   
        &GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_KEY_SCHEMA,
  213    213   
        &GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_PROJECTION,
  214    214   
        &GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_STATUS,
@@ -244,244 +361,369 @@
  264    264   
            ser.write_long(&GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_ITEM_COUNT, *val)?;
  265    265   
        }
  266    266   
        if let Some(ref val) = self.index_arn {
  267    267   
            ser.write_string(&GLOBALSECONDARYINDEXDESCRIPTION_MEMBER_INDEX_ARN, val)?;
  268    268   
        }
  269    269   
        Ok(())
  270    270   
    }
  271    271   
}
  272    272   
impl GlobalSecondaryIndexDescription {
  273    273   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  274         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  275         -
        deserializer: &mut D,
         274  +
    pub fn deserialize(
         275  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  276    276   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  277    277   
        #[allow(unused_variables, unused_mut)]
  278    278   
        let mut builder = Self::builder();
  279    279   
        #[allow(
  280    280   
            unused_variables,
  281    281   
            unreachable_code,
  282    282   
            clippy::single_match,
  283    283   
            clippy::match_single_binding,
  284    284   
            clippy::diverging_sub_expression
  285    285   
        )]
  286         -
        deserializer.read_struct(&GLOBALSECONDARYINDEXDESCRIPTION_SCHEMA, (), |_, member, deser| {
         286  +
        deserializer.read_struct(&GLOBALSECONDARYINDEXDESCRIPTION_SCHEMA, &mut |member, deser| {
  287    287   
            match member.member_index() {
  288    288   
                Some(0) => {
  289    289   
                    builder.index_name = Some(deser.read_string(member)?);
  290    290   
                }
  291    291   
                Some(1) => {
  292    292   
                    builder.key_schema = Some({
  293         -
                        let container = if let Some(cap) = deser.container_size() {
  294         -
                            Vec::with_capacity(cap)
  295         -
                        } else {
  296         -
                            Vec::new()
  297         -
                        };
  298         -
                        deser.read_list(member, container, |mut list, deser| {
  299         -
                            list.push(crate::types::KeySchemaElement::deserialize(deser)?);
  300         -
                            Ok(list)
  301         -
                        })?
         293  +
                        let mut container = Vec::new();
         294  +
                        deser.read_list(member, &mut |deser| {
         295  +
                            container.push(crate::types::KeySchemaElement::deserialize(deser)?);
         296  +
                            Ok(())
         297  +
                        })?;
         298  +
                        container
  302    299   
                    });
  303    300   
                }
  304    301   
                Some(2) => {
  305    302   
                    builder.projection = Some(crate::types::Projection::deserialize(deser)?);
  306    303   
                }
  307    304   
                Some(3) => {
  308    305   
                    builder.index_status = Some(crate::types::IndexStatus::from(deser.read_string(member)?.as_str()));
  309    306   
                }
  310    307   
                Some(4) => {
  311    308   
                    builder.backfilling = Some(deser.read_boolean(member)?);
  312    309   
                }
  313    310   
                Some(5) => {
  314    311   
                    builder.provisioned_throughput = Some(crate::types::ProvisionedThroughputDescription::deserialize(deser)?);
  315    312   
                }
  316    313   
                Some(6) => {
  317    314   
                    builder.index_size_bytes = Some(deser.read_long(member)?);
  318    315   
                }
  319    316   
                Some(7) => {
  320    317   
                    builder.item_count = Some(deser.read_long(member)?);
  321    318   
                }
  322    319   
                Some(8) => {
  323    320   
                    builder.index_arn = Some(deser.read_string(member)?);
  324    321   
                }
  325    322   
                _ => {}
  326    323   
            }
  327    324   
            Ok(())
  328    325   
        })?;
  329    326   
        Ok(builder.build())
  330    327   
    }
  331    328   
}
         329  +
impl GlobalSecondaryIndexDescription {
         330  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         331  +
    pub fn deserialize_with_response(
         332  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         333  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         334  +
        _status: u16,
         335  +
        _body: &[u8],
         336  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         337  +
        Self::deserialize(deserializer)
         338  +
    }
         339  +
}
  332    340   
impl GlobalSecondaryIndexDescription {
  333    341   
    /// Creates a new builder-style object to manufacture [`GlobalSecondaryIndexDescription`](crate::types::GlobalSecondaryIndexDescription).
  334    342   
    pub fn builder() -> crate::types::builders::GlobalSecondaryIndexDescriptionBuilder {
  335    343   
        crate::types::builders::GlobalSecondaryIndexDescriptionBuilder::default()
  336    344   
    }
  337    345   
}
  338    346   
  339    347   
/// A builder for [`GlobalSecondaryIndexDescription`](crate::types::GlobalSecondaryIndexDescription).
  340    348   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  341    349   
#[non_exhaustive]

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

@@ -36,36 +216,224 @@
   56     56   
    "com.amazonaws.dynamodb",
   57     57   
    "GlobalSecondaryIndexInfo",
   58     58   
);
   59     59   
static GLOBALSECONDARYINDEXINFO_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#GlobalSecondaryIndexInfo$IndexName",
   62     62   
        "com.amazonaws.dynamodb",
   63     63   
        "GlobalSecondaryIndexInfo",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "index_name",
          66  +
    "IndexName",
   67     67   
    0,
   68     68   
);
   69     69   
static GLOBALSECONDARYINDEXINFO_MEMBER_KEY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexInfo$KeySchema",
   72     72   
        "com.amazonaws.dynamodb",
   73     73   
        "GlobalSecondaryIndexInfo",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::List,
   76         -
    "key_schema",
          76  +
    "KeySchema",
   77     77   
    1,
   78     78   
);
   79     79   
static GLOBALSECONDARYINDEXINFO_MEMBER_PROJECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexInfo$Projection",
   82     82   
        "com.amazonaws.dynamodb",
   83     83   
        "GlobalSecondaryIndexInfo",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86         -
    "projection",
          86  +
    "Projection",
   87     87   
    2,
   88     88   
);
   89     89   
static GLOBALSECONDARYINDEXINFO_MEMBER_PROVISIONED_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexInfo$ProvisionedThroughput",
   92     92   
        "com.amazonaws.dynamodb",
   93     93   
        "GlobalSecondaryIndexInfo",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::Structure,
   96         -
    "provisioned_throughput",
          96  +
    "ProvisionedThroughput",
   97     97   
    3,
   98     98   
);
   99     99   
static GLOBALSECONDARYINDEXINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  100    100   
    GLOBALSECONDARYINDEXINFO_SCHEMA_ID,
  101    101   
    ::aws_smithy_schema::ShapeType::Structure,
  102    102   
    &[
  103    103   
        &GLOBALSECONDARYINDEXINFO_MEMBER_INDEX_NAME,
  104    104   
        &GLOBALSECONDARYINDEXINFO_MEMBER_KEY_SCHEMA,
  105    105   
        &GLOBALSECONDARYINDEXINFO_MEMBER_PROJECTION,
  106    106   
        &GLOBALSECONDARYINDEXINFO_MEMBER_PROVISIONED_THROUGHPUT,
  107    107   
    ],
  108    108   
);
  109    109   
impl GlobalSecondaryIndexInfo {
  110    110   
    /// The schema for this shape.
  111    111   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GLOBALSECONDARYINDEXINFO_SCHEMA;
  112    112   
}
  113    113   
impl ::aws_smithy_schema::serde::SerializableStruct for GlobalSecondaryIndexInfo {
  114    114   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  115    115   
    fn serialize_members(
  116    116   
        &self,
  117    117   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  118    118   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  119    119   
        if let Some(ref val) = self.index_name {
  120    120   
            ser.write_string(&GLOBALSECONDARYINDEXINFO_MEMBER_INDEX_NAME, val)?;
  121    121   
        }
  122    122   
        if let Some(ref val) = self.key_schema {
  123    123   
            ser.write_list(
  124    124   
                &GLOBALSECONDARYINDEXINFO_MEMBER_KEY_SCHEMA,
  125    125   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  126    126   
                    for item in val {
  127    127   
                        ser.write_struct(crate::types::KeySchemaElement::SCHEMA, item)?;
  128    128   
                    }
  129    129   
                    Ok(())
  130    130   
                },
  131    131   
            )?;
  132    132   
        }
  133    133   
        if let Some(ref val) = self.projection {
  134    134   
            ser.write_struct(&GLOBALSECONDARYINDEXINFO_MEMBER_PROJECTION, val)?;
  135    135   
        }
  136    136   
        if let Some(ref val) = self.provisioned_throughput {
  137    137   
            ser.write_struct(&GLOBALSECONDARYINDEXINFO_MEMBER_PROVISIONED_THROUGHPUT, val)?;
  138    138   
        }
  139    139   
        Ok(())
  140    140   
    }
  141    141   
}
  142    142   
impl GlobalSecondaryIndexInfo {
  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(&GLOBALSECONDARYINDEXINFO_SCHEMA, (), |_, member, deser| {
         156  +
        deserializer.read_struct(&GLOBALSECONDARYINDEXINFO_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.key_schema = Some({
  163         -
                        let container = if let Some(cap) = deser.container_size() {
  164         -
                            Vec::with_capacity(cap)
  165         -
                        } else {
  166         -
                            Vec::new()
  167         -
                        };
  168         -
                        deser.read_list(member, container, |mut list, deser| {
  169         -
                            list.push(crate::types::KeySchemaElement::deserialize(deser)?);
  170         -
                            Ok(list)
  171         -
                        })?
         163  +
                        let mut container = Vec::new();
         164  +
                        deser.read_list(member, &mut |deser| {
         165  +
                            container.push(crate::types::KeySchemaElement::deserialize(deser)?);
         166  +
                            Ok(())
         167  +
                        })?;
         168  +
                        container
  172    169   
                    });
  173    170   
                }
  174    171   
                Some(2) => {
  175    172   
                    builder.projection = Some(crate::types::Projection::deserialize(deser)?);
  176    173   
                }
  177    174   
                Some(3) => {
  178    175   
                    builder.provisioned_throughput = Some(crate::types::ProvisionedThroughput::deserialize(deser)?);
  179    176   
                }
  180    177   
                _ => {}
  181    178   
            }
  182    179   
            Ok(())
  183    180   
        })?;
  184    181   
        Ok(builder.build())
  185    182   
    }
  186    183   
}
         184  +
impl GlobalSecondaryIndexInfo {
         185  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         186  +
    pub fn deserialize_with_response(
         187  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         188  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         189  +
        _status: u16,
         190  +
        _body: &[u8],
         191  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         192  +
        Self::deserialize(deserializer)
         193  +
    }
         194  +
}
  187    195   
impl GlobalSecondaryIndexInfo {
  188    196   
    /// Creates a new builder-style object to manufacture [`GlobalSecondaryIndexInfo`](crate::types::GlobalSecondaryIndexInfo).
  189    197   
    pub fn builder() -> crate::types::builders::GlobalSecondaryIndexInfoBuilder {
  190    198   
        crate::types::builders::GlobalSecondaryIndexInfoBuilder::default()
  191    199   
    }
  192    200   
}
  193    201   
  194    202   
/// A builder for [`GlobalSecondaryIndexInfo`](crate::types::GlobalSecondaryIndexInfo).
  195    203   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  196    204   
#[non_exhaustive]

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

@@ -42,42 +187,198 @@
   62     62   
    "com.amazonaws.dynamodb",
   63     63   
    "GlobalSecondaryIndexUpdate",
   64     64   
);
   65     65   
static GLOBALSECONDARYINDEXUPDATE_MEMBER_UPDATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static(
   67     67   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexUpdate$Update",
   68     68   
        "com.amazonaws.dynamodb",
   69     69   
        "GlobalSecondaryIndexUpdate",
   70     70   
    ),
   71     71   
    ::aws_smithy_schema::ShapeType::Structure,
   72         -
    "update",
          72  +
    "Update",
   73     73   
    0,
   74     74   
);
   75     75   
static GLOBALSECONDARYINDEXUPDATE_MEMBER_CREATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static(
   77     77   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexUpdate$Create",
   78     78   
        "com.amazonaws.dynamodb",
   79     79   
        "GlobalSecondaryIndexUpdate",
   80     80   
    ),
   81     81   
    ::aws_smithy_schema::ShapeType::Structure,
   82         -
    "create",
          82  +
    "Create",
   83     83   
    1,
   84     84   
);
   85     85   
static GLOBALSECONDARYINDEXUPDATE_MEMBER_DELETE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "com.amazonaws.dynamodb#GlobalSecondaryIndexUpdate$Delete",
   88     88   
        "com.amazonaws.dynamodb",
   89     89   
        "GlobalSecondaryIndexUpdate",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::Structure,
   92         -
    "delete",
          92  +
    "Delete",
   93     93   
    2,
   94     94   
);
   95     95   
static GLOBALSECONDARYINDEXUPDATE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   96     96   
    GLOBALSECONDARYINDEXUPDATE_SCHEMA_ID,
   97     97   
    ::aws_smithy_schema::ShapeType::Structure,
   98     98   
    &[
   99     99   
        &GLOBALSECONDARYINDEXUPDATE_MEMBER_UPDATE,
  100    100   
        &GLOBALSECONDARYINDEXUPDATE_MEMBER_CREATE,
  101    101   
        &GLOBALSECONDARYINDEXUPDATE_MEMBER_DELETE,
  102    102   
    ],
  103    103   
);
  104    104   
impl GlobalSecondaryIndexUpdate {
  105    105   
    /// The schema for this shape.
  106    106   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GLOBALSECONDARYINDEXUPDATE_SCHEMA;
  107    107   
}
  108    108   
impl ::aws_smithy_schema::serde::SerializableStruct for GlobalSecondaryIndexUpdate {
  109    109   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  110    110   
    fn serialize_members(
  111    111   
        &self,
  112    112   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  113    113   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  114    114   
        if let Some(ref val) = self.update {
  115    115   
            ser.write_struct(&GLOBALSECONDARYINDEXUPDATE_MEMBER_UPDATE, val)?;
  116    116   
        }
  117    117   
        if let Some(ref val) = self.create {
  118    118   
            ser.write_struct(&GLOBALSECONDARYINDEXUPDATE_MEMBER_CREATE, val)?;
  119    119   
        }
  120    120   
        if let Some(ref val) = self.delete {
  121    121   
            ser.write_struct(&GLOBALSECONDARYINDEXUPDATE_MEMBER_DELETE, val)?;
  122    122   
        }
  123    123   
        Ok(())
  124    124   
    }
  125    125   
}
  126    126   
impl GlobalSecondaryIndexUpdate {
  127    127   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  128         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  129         -
        deserializer: &mut D,
         128  +
    pub fn deserialize(
         129  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  130    130   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  131    131   
        #[allow(unused_variables, unused_mut)]
  132    132   
        let mut builder = Self::builder();
  133    133   
        #[allow(
  134    134   
            unused_variables,
  135    135   
            unreachable_code,
  136    136   
            clippy::single_match,
  137    137   
            clippy::match_single_binding,
  138    138   
            clippy::diverging_sub_expression
  139    139   
        )]
  140         -
        deserializer.read_struct(&GLOBALSECONDARYINDEXUPDATE_SCHEMA, (), |_, member, deser| {
         140  +
        deserializer.read_struct(&GLOBALSECONDARYINDEXUPDATE_SCHEMA, &mut |member, deser| {
  141    141   
            match member.member_index() {
  142    142   
                Some(0) => {
  143    143   
                    builder.update = Some(crate::types::UpdateGlobalSecondaryIndexAction::deserialize(deser)?);
  144    144   
                }
  145    145   
                Some(1) => {
  146    146   
                    builder.create = Some(crate::types::CreateGlobalSecondaryIndexAction::deserialize(deser)?);
  147    147   
                }
  148    148   
                Some(2) => {
  149    149   
                    builder.delete = Some(crate::types::DeleteGlobalSecondaryIndexAction::deserialize(deser)?);
  150    150   
                }
  151    151   
                _ => {}
  152    152   
            }
  153    153   
            Ok(())
  154    154   
        })?;
  155    155   
        Ok(builder.build())
  156    156   
    }
  157    157   
}
         158  +
impl GlobalSecondaryIndexUpdate {
         159  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         160  +
    pub fn deserialize_with_response(
         161  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         162  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         163  +
        _status: u16,
         164  +
        _body: &[u8],
         165  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         166  +
        Self::deserialize(deserializer)
         167  +
    }
         168  +
}
  158    169   
impl GlobalSecondaryIndexUpdate {
  159    170   
    /// Creates a new builder-style object to manufacture [`GlobalSecondaryIndexUpdate`](crate::types::GlobalSecondaryIndexUpdate).
  160    171   
    pub fn builder() -> crate::types::builders::GlobalSecondaryIndexUpdateBuilder {
  161    172   
        crate::types::builders::GlobalSecondaryIndexUpdateBuilder::default()
  162    173   
    }
  163    174   
}
  164    175   
  165    176   
/// A builder for [`GlobalSecondaryIndexUpdate`](crate::types::GlobalSecondaryIndexUpdate).
  166    177   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  167    178   
#[non_exhaustive]

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

@@ -3,3 +146,154 @@
   23     23   
}
   24     24   
static GLOBALTABLE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#GlobalTable", "com.amazonaws.dynamodb", "GlobalTable");
   26     26   
static GLOBALTABLE_MEMBER_GLOBAL_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static(
   28     28   
        "com.amazonaws.dynamodb#GlobalTable$GlobalTableName",
   29     29   
        "com.amazonaws.dynamodb",
   30     30   
        "GlobalTable",
   31     31   
    ),
   32     32   
    ::aws_smithy_schema::ShapeType::String,
   33         -
    "global_table_name",
          33  +
    "GlobalTableName",
   34     34   
    0,
   35     35   
);
   36     36   
static GLOBALTABLE_MEMBER_REPLICATION_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static(
   38     38   
        "com.amazonaws.dynamodb#GlobalTable$ReplicationGroup",
   39     39   
        "com.amazonaws.dynamodb",
   40     40   
        "GlobalTable",
   41     41   
    ),
   42     42   
    ::aws_smithy_schema::ShapeType::List,
   43         -
    "replication_group",
          43  +
    "ReplicationGroup",
   44     44   
    1,
   45     45   
);
   46     46   
static GLOBALTABLE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   47     47   
    GLOBALTABLE_SCHEMA_ID,
   48     48   
    ::aws_smithy_schema::ShapeType::Structure,
   49     49   
    &[&GLOBALTABLE_MEMBER_GLOBAL_TABLE_NAME, &GLOBALTABLE_MEMBER_REPLICATION_GROUP],
   50     50   
);
   51     51   
impl GlobalTable {
   52     52   
    /// The schema for this shape.
   53     53   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GLOBALTABLE_SCHEMA;
   54     54   
}
   55     55   
impl ::aws_smithy_schema::serde::SerializableStruct for GlobalTable {
   56     56   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   57     57   
    fn serialize_members(
   58     58   
        &self,
   59     59   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   60     60   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   61     61   
        if let Some(ref val) = self.global_table_name {
   62     62   
            ser.write_string(&GLOBALTABLE_MEMBER_GLOBAL_TABLE_NAME, val)?;
   63     63   
        }
   64     64   
        if let Some(ref val) = self.replication_group {
   65     65   
            ser.write_list(
   66     66   
                &GLOBALTABLE_MEMBER_REPLICATION_GROUP,
   67     67   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   68     68   
                    for item in val {
   69     69   
                        ser.write_struct(crate::types::Replica::SCHEMA, item)?;
   70     70   
                    }
   71     71   
                    Ok(())
   72     72   
                },
   73     73   
            )?;
   74     74   
        }
   75     75   
        Ok(())
   76     76   
    }
   77     77   
}
   78     78   
impl GlobalTable {
   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(&GLOBALTABLE_SCHEMA, (), |_, member, deser| {
          92  +
        deserializer.read_struct(&GLOBALTABLE_SCHEMA, &mut |member, deser| {
   93     93   
            match member.member_index() {
   94     94   
                Some(0) => {
   95     95   
                    builder.global_table_name = Some(deser.read_string(member)?);
   96     96   
                }
   97     97   
                Some(1) => {
   98     98   
                    builder.replication_group = Some({
   99         -
                        let container = if let Some(cap) = deser.container_size() {
  100         -
                            Vec::with_capacity(cap)
  101         -
                        } else {
  102         -
                            Vec::new()
  103         -
                        };
  104         -
                        deser.read_list(member, container, |mut list, deser| {
  105         -
                            list.push(crate::types::Replica::deserialize(deser)?);
  106         -
                            Ok(list)
  107         -
                        })?
          99  +
                        let mut container = Vec::new();
         100  +
                        deser.read_list(member, &mut |deser| {
         101  +
                            container.push(crate::types::Replica::deserialize(deser)?);
         102  +
                            Ok(())
         103  +
                        })?;
         104  +
                        container
  108    105   
                    });
  109    106   
                }
  110    107   
                _ => {}
  111    108   
            }
  112    109   
            Ok(())
  113    110   
        })?;
  114    111   
        Ok(builder.build())
  115    112   
    }
  116    113   
}
         114  +
impl GlobalTable {
         115  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         116  +
    pub fn deserialize_with_response(
         117  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         118  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         119  +
        _status: u16,
         120  +
        _body: &[u8],
         121  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         122  +
        Self::deserialize(deserializer)
         123  +
    }
         124  +
}
  117    125   
impl GlobalTable {
  118    126   
    /// Creates a new builder-style object to manufacture [`GlobalTable`](crate::types::GlobalTable).
  119    127   
    pub fn builder() -> crate::types::builders::GlobalTableBuilder {
  120    128   
        crate::types::builders::GlobalTableBuilder::default()
  121    129   
    }
  122    130   
}
  123    131   
  124    132   
/// A builder for [`GlobalTable`](crate::types::GlobalTable).
  125    133   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  126    134   
#[non_exhaustive]

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

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