AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36 (ignoring whitespace)

Files changed:

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

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

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

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

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

@@ -92,92 +178,189 @@
  112    112   
            ser.write_string(&THROTTLINGREASON_MEMBER_REASON, val)?;
  113    113   
        }
  114    114   
        if let Some(ref val) = self.resource {
  115    115   
            ser.write_string(&THROTTLINGREASON_MEMBER_RESOURCE, val)?;
  116    116   
        }
  117    117   
        Ok(())
  118    118   
    }
  119    119   
}
  120    120   
impl ThrottlingReason {
  121    121   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  122         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  123         -
        deserializer: &mut D,
         122  +
    pub fn deserialize(
         123  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  124    124   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  125    125   
        #[allow(unused_variables, unused_mut)]
  126    126   
        let mut builder = Self::builder();
  127    127   
        #[allow(
  128    128   
            unused_variables,
  129    129   
            unreachable_code,
  130    130   
            clippy::single_match,
  131    131   
            clippy::match_single_binding,
  132    132   
            clippy::diverging_sub_expression
  133    133   
        )]
  134         -
        deserializer.read_struct(&THROTTLINGREASON_SCHEMA, (), |_, member, deser| {
         134  +
        deserializer.read_struct(&THROTTLINGREASON_SCHEMA, &mut |member, deser| {
  135    135   
            match member.member_index() {
  136    136   
                Some(0) => {
  137    137   
                    builder.reason = Some(deser.read_string(member)?);
  138    138   
                }
  139    139   
                Some(1) => {
  140    140   
                    builder.resource = Some(deser.read_string(member)?);
  141    141   
                }
  142    142   
                _ => {}
  143    143   
            }
  144    144   
            Ok(())
  145    145   
        })?;
  146    146   
        Ok(builder.build())
  147    147   
    }
  148    148   
}
         149  +
impl ThrottlingReason {
         150  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         151  +
    pub fn deserialize_with_response(
         152  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         153  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         154  +
        _status: u16,
         155  +
        _body: &[u8],
         156  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         157  +
        Self::deserialize(deserializer)
         158  +
    }
         159  +
}
  149    160   
impl ThrottlingReason {
  150    161   
    /// Creates a new builder-style object to manufacture [`ThrottlingReason`](crate::types::ThrottlingReason).
  151    162   
    pub fn builder() -> crate::types::builders::ThrottlingReasonBuilder {
  152    163   
        crate::types::builders::ThrottlingReasonBuilder::default()
  153    164   
    }
  154    165   
}
  155    166   
  156    167   
/// A builder for [`ThrottlingReason`](crate::types::ThrottlingReason).
  157    168   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  158    169   
#[non_exhaustive]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,1 +129,140 @@
   21     21   
}
   22     22   
static WARMTHROUGHPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.dynamodb#WarmThroughput", "com.amazonaws.dynamodb", "WarmThroughput");
   24     24   
static WARMTHROUGHPUT_MEMBER_READ_UNITS_PER_SECOND: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static(
   26     26   
        "com.amazonaws.dynamodb#WarmThroughput$ReadUnitsPerSecond",
   27     27   
        "com.amazonaws.dynamodb",
   28     28   
        "WarmThroughput",
   29     29   
    ),
   30     30   
    ::aws_smithy_schema::ShapeType::Long,
   31         -
    "read_units_per_second",
          31  +
    "ReadUnitsPerSecond",
   32     32   
    0,
   33     33   
);
   34     34   
static WARMTHROUGHPUT_MEMBER_WRITE_UNITS_PER_SECOND: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   35     35   
    ::aws_smithy_schema::ShapeId::from_static(
   36     36   
        "com.amazonaws.dynamodb#WarmThroughput$WriteUnitsPerSecond",
   37     37   
        "com.amazonaws.dynamodb",
   38     38   
        "WarmThroughput",
   39     39   
    ),
   40     40   
    ::aws_smithy_schema::ShapeType::Long,
   41         -
    "write_units_per_second",
          41  +
    "WriteUnitsPerSecond",
   42     42   
    1,
   43     43   
);
   44     44   
static WARMTHROUGHPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   45     45   
    WARMTHROUGHPUT_SCHEMA_ID,
   46     46   
    ::aws_smithy_schema::ShapeType::Structure,
   47     47   
    &[
   48     48   
        &WARMTHROUGHPUT_MEMBER_READ_UNITS_PER_SECOND,
   49     49   
        &WARMTHROUGHPUT_MEMBER_WRITE_UNITS_PER_SECOND,
   50     50   
    ],
   51     51   
);
   52     52   
impl WarmThroughput {
   53     53   
    /// The schema for this shape.
   54     54   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &WARMTHROUGHPUT_SCHEMA;
   55     55   
}
   56     56   
impl ::aws_smithy_schema::serde::SerializableStruct for WarmThroughput {
   57     57   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   58     58   
    fn serialize_members(
   59     59   
        &self,
   60     60   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   61     61   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   62     62   
        if let Some(ref val) = self.read_units_per_second {
   63     63   
            ser.write_long(&WARMTHROUGHPUT_MEMBER_READ_UNITS_PER_SECOND, *val)?;
   64     64   
        }
   65     65   
        if let Some(ref val) = self.write_units_per_second {
   66     66   
            ser.write_long(&WARMTHROUGHPUT_MEMBER_WRITE_UNITS_PER_SECOND, *val)?;
   67     67   
        }
   68     68   
        Ok(())
   69     69   
    }
   70     70   
}
   71     71   
impl WarmThroughput {
   72     72   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   73         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   74         -
        deserializer: &mut D,
          73  +
    pub fn deserialize(
          74  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   75     75   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   76     76   
        #[allow(unused_variables, unused_mut)]
   77     77   
        let mut builder = Self::builder();
   78     78   
        #[allow(
   79     79   
            unused_variables,
   80     80   
            unreachable_code,
   81     81   
            clippy::single_match,
   82     82   
            clippy::match_single_binding,
   83     83   
            clippy::diverging_sub_expression
   84     84   
        )]
   85         -
        deserializer.read_struct(&WARMTHROUGHPUT_SCHEMA, (), |_, member, deser| {
          85  +
        deserializer.read_struct(&WARMTHROUGHPUT_SCHEMA, &mut |member, deser| {
   86     86   
            match member.member_index() {
   87     87   
                Some(0) => {
   88     88   
                    builder.read_units_per_second = Some(deser.read_long(member)?);
   89     89   
                }
   90     90   
                Some(1) => {
   91     91   
                    builder.write_units_per_second = Some(deser.read_long(member)?);
   92     92   
                }
   93     93   
                _ => {}
   94     94   
            }
   95     95   
            Ok(())
   96     96   
        })?;
   97     97   
        Ok(builder.build())
   98     98   
    }
   99     99   
}
         100  +
impl WarmThroughput {
         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  +
}
  100    111   
impl WarmThroughput {
  101    112   
    /// Creates a new builder-style object to manufacture [`WarmThroughput`](crate::types::WarmThroughput).
  102    113   
    pub fn builder() -> crate::types::builders::WarmThroughputBuilder {
  103    114   
        crate::types::builders::WarmThroughputBuilder::default()
  104    115   
    }
  105    116   
}
  106    117   
  107    118   
/// A builder for [`WarmThroughput`](crate::types::WarmThroughput).
  108    119   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  109    120   
#[non_exhaustive]

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

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

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

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&BACKUPINUSEEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl BackupInUseException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&BACKUPINUSEEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&BACKUPINUSEEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl BackupInUseException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl BackupInUseException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for BackupInUseException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "BackupInUseException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&BACKUPNOTFOUNDEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl BackupNotFoundException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&BACKUPNOTFOUNDEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&BACKUPNOTFOUNDEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl BackupNotFoundException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl BackupNotFoundException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for BackupNotFoundException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "BackupNotFoundException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -11,11 +148,156 @@
   31     31   
    "message",
   32     32   
    0,
   33     33   
);
   34     34   
static CONDITIONALCHECKFAILEDEXCEPTION_MEMBER_ITEM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   35     35   
    ::aws_smithy_schema::ShapeId::from_static(
   36     36   
        "com.amazonaws.dynamodb#ConditionalCheckFailedException$Item",
   37     37   
        "com.amazonaws.dynamodb",
   38     38   
        "ConditionalCheckFailedException",
   39     39   
    ),
   40     40   
    ::aws_smithy_schema::ShapeType::Map,
   41         -
    "item",
          41  +
    "Item",
   42     42   
    1,
   43     43   
);
   44     44   
static CONDITIONALCHECKFAILEDEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   45     45   
    CONDITIONALCHECKFAILEDEXCEPTION_SCHEMA_ID,
   46     46   
    ::aws_smithy_schema::ShapeType::Structure,
   47     47   
    &[
   48     48   
        &CONDITIONALCHECKFAILEDEXCEPTION_MEMBER_MESSAGE,
   49     49   
        &CONDITIONALCHECKFAILEDEXCEPTION_MEMBER_ITEM,
   50     50   
    ],
   51     51   
);
   52     52   
impl ConditionalCheckFailedException {
   53     53   
    /// The schema for this shape.
   54     54   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONDITIONALCHECKFAILEDEXCEPTION_SCHEMA;
   55     55   
}
   56     56   
impl ::aws_smithy_schema::serde::SerializableStruct for ConditionalCheckFailedException {
   57     57   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   58     58   
    fn serialize_members(
   59     59   
        &self,
   60     60   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   61     61   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   62     62   
        if let Some(ref val) = self.message {
   63     63   
            ser.write_string(&CONDITIONALCHECKFAILEDEXCEPTION_MEMBER_MESSAGE, val)?;
   64     64   
        }
   65     65   
        if let Some(ref val) = self.item {
   66     66   
            ser.write_map(
   67     67   
                &CONDITIONALCHECKFAILEDEXCEPTION_MEMBER_ITEM,
   68     68   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   69     69   
                    for (key, value) in val {
   70     70   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   71         -
                        todo!("schema: unsupported map value type");
          71  +
                        ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
   72     72   
                    }
   73     73   
                    Ok(())
   74     74   
                },
   75     75   
            )?;
   76     76   
        }
   77     77   
        Ok(())
   78     78   
    }
   79     79   
}
   80     80   
impl ConditionalCheckFailedException {
   81     81   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   82         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   83         -
        deserializer: &mut D,
          82  +
    pub fn deserialize(
          83  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   84     84   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   85     85   
        #[allow(unused_variables, unused_mut)]
   86     86   
        let mut builder = Self::builder();
   87     87   
        #[allow(
   88     88   
            unused_variables,
   89     89   
            unreachable_code,
   90     90   
            clippy::single_match,
   91     91   
            clippy::match_single_binding,
   92     92   
            clippy::diverging_sub_expression
   93     93   
        )]
   94         -
        deserializer.read_struct(&CONDITIONALCHECKFAILEDEXCEPTION_SCHEMA, (), |_, member, deser| {
          94  +
        deserializer.read_struct(&CONDITIONALCHECKFAILEDEXCEPTION_SCHEMA, &mut |member, deser| {
   95     95   
            match member.member_index() {
   96     96   
                Some(0) => {
   97     97   
                    builder.message = Some(deser.read_string(member)?);
   98     98   
                }
   99     99   
                Some(1) => {
  100    100   
                    builder.item = Some({
  101         -
                        let container = if let Some(cap) = deser.container_size() {
  102         -
                            std::collections::HashMap::with_capacity(cap)
  103         -
                        } else {
  104         -
                            std::collections::HashMap::new()
  105         -
                        };
  106         -
                        deser.read_map(member, container, |mut map, key, deser| {
  107         -
                            map.insert(key, todo!("deserialize nested aggregate"));
  108         -
                            Ok(map)
  109         -
                        })?
         101  +
                        let mut container = std::collections::HashMap::new();
         102  +
                        deser.read_map(member, &mut |key, deser| {
         103  +
                            container.insert(key, crate::types::AttributeValue::deserialize(deser)?);
         104  +
                            Ok(())
         105  +
                        })?;
         106  +
                        container
  110    107   
                    });
  111    108   
                }
  112    109   
                _ => {}
  113    110   
            }
  114    111   
            Ok(())
  115    112   
        })?;
  116    113   
        Ok(builder.build())
  117    114   
    }
  118    115   
}
         116  +
impl ConditionalCheckFailedException {
         117  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         118  +
    pub fn deserialize_with_response(
         119  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         120  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         121  +
        _status: u16,
         122  +
        _body: &[u8],
         123  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         124  +
        Self::deserialize(deserializer)
         125  +
    }
         126  +
}
  119    127   
impl ConditionalCheckFailedException {
  120    128   
    /// Returns the error message.
  121    129   
    pub fn message(&self) -> ::std::option::Option<&str> {
  122    130   
        self.message.as_deref()
  123    131   
    }
  124    132   
}
  125    133   
impl ::std::fmt::Display for ConditionalCheckFailedException {
  126    134   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  127    135   
        ::std::write!(f, "ConditionalCheckFailedException")?;
  128    136   
        if let ::std::option::Option::Some(inner_1) = &self.message {