AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045

Files changed:

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/error/_point_in_time_recovery_unavailable_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(&POINTINTIMERECOVERYUNAVAILABLEEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl PointInTimeRecoveryUnavailableException {
   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(&POINTINTIMERECOVERYUNAVAILABLEEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&POINTINTIMERECOVERYUNAVAILABLEEXCEPTION_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 PointInTimeRecoveryUnavailableException {
          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 PointInTimeRecoveryUnavailableException {
   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 PointInTimeRecoveryUnavailableException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "PointInTimeRecoveryUnavailableException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

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

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

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/error/_replica_already_exists_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(&REPLICAALREADYEXISTSEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl ReplicaAlreadyExistsException {
   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(&REPLICAALREADYEXISTSEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&REPLICAALREADYEXISTSEXCEPTION_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 ReplicaAlreadyExistsException {
          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 ReplicaAlreadyExistsException {
   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 ReplicaAlreadyExistsException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "ReplicaAlreadyExistsException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/error/_replica_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(&REPLICANOTFOUNDEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl ReplicaNotFoundException {
   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(&REPLICANOTFOUNDEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&REPLICANOTFOUNDEXCEPTION_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 ReplicaNotFoundException {
          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 ReplicaNotFoundException {
   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 ReplicaNotFoundException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "ReplicaNotFoundException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/error/_replicated_write_conflict_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(&REPLICATEDWRITECONFLICTEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl ReplicatedWriteConflictException {
   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(&REPLICATEDWRITECONFLICTEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&REPLICATEDWRITECONFLICTEXCEPTION_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 ReplicatedWriteConflictException {
          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 ReplicatedWriteConflictException {
   74     85   
    /// Returns `Some(ErrorKind)` if the error is retryable. Otherwise, returns `None`.
   75     86   
    pub fn retryable_error_kind(&self) -> ::aws_smithy_types::retry::ErrorKind {
   76     87   
        ::aws_smithy_types::retry::ErrorKind::ClientError
   77     88   
    }
   78     89   
    /// Returns the error message.
   79     90   
    pub fn message(&self) -> ::std::option::Option<&str> {
   80     91   
        self.message.as_deref()
   81     92   
    }
   82     93   
}

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

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

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

@@ -28,28 +111,122 @@
   48     48   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   49     49   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   50     50   
        if let Some(ref val) = self.message {
   51     51   
            ser.write_string(&RESOURCEINUSEEXCEPTION_MEMBER_MESSAGE, val)?;
   52     52   
        }
   53     53   
        Ok(())
   54     54   
    }
   55     55   
}
   56     56   
impl ResourceInUseException {
   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(&RESOURCEINUSEEXCEPTION_SCHEMA, (), |_, member, deser| {
          70  +
        deserializer.read_struct(&RESOURCEINUSEEXCEPTION_SCHEMA, &mut |member, deser| {
   71     71   
            match member.member_index() {
   72     72   
                Some(0) => {
   73     73   
                    builder.message = Some(deser.read_string(member)?);
   74     74   
                }
   75     75   
                _ => {}
   76     76   
            }
   77     77   
            Ok(())
   78     78   
        })?;
   79     79   
        Ok(builder.build())
   80     80   
    }
   81     81   
}
          82  +
impl ResourceInUseException {
          83  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          84  +
    pub fn deserialize_with_response(
          85  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          86  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          87  +
        _status: u16,
          88  +
        _body: &[u8],
          89  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          90  +
        Self::deserialize(deserializer)
          91  +
    }
          92  +
}
   82     93   
impl ResourceInUseException {
   83     94   
    /// Returns the error message.
   84     95   
    pub fn message(&self) -> ::std::option::Option<&str> {
   85     96   
        self.message.as_deref()
   86     97   
    }
   87     98   
}
   88     99   
impl ::std::fmt::Display for ResourceInUseException {
   89    100   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   90    101   
        ::std::write!(f, "ResourceInUseException")?;
   91    102   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/error/_resource_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(&RESOURCENOTFOUNDEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl ResourceNotFoundException {
   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(&RESOURCENOTFOUNDEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&RESOURCENOTFOUNDEXCEPTION_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 ResourceNotFoundException {
          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 ResourceNotFoundException {
   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 ResourceNotFoundException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "ResourceNotFoundException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/error/_table_already_exists_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(&TABLEALREADYEXISTSEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl TableAlreadyExistsException {
   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(&TABLEALREADYEXISTSEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&TABLEALREADYEXISTSEXCEPTION_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 TableAlreadyExistsException {
          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 TableAlreadyExistsException {
   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 TableAlreadyExistsException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "TableAlreadyExistsException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/error/_table_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(&TABLEINUSEEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl TableInUseException {
   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(&TABLEINUSEEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&TABLEINUSEEXCEPTION_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 TableInUseException {
          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 TableInUseException {
   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 TableInUseException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "TableInUseException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/error/_table_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(&TABLENOTFOUNDEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl TableNotFoundException {
   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(&TABLENOTFOUNDEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&TABLENOTFOUNDEXCEPTION_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 TableNotFoundException {
          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 TableNotFoundException {
   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 TableNotFoundException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "TableNotFoundException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -13,13 +155,163 @@
   33     33   
    "message",
   34     34   
    0,
   35     35   
);
   36     36   
static THROTTLINGEXCEPTION_MEMBER_THROTTLING_REASONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static(
   38     38   
        "com.amazonaws.dynamodb#ThrottlingException$throttlingReasons",
   39     39   
        "com.amazonaws.dynamodb",
   40     40   
        "ThrottlingException",
   41     41   
    ),
   42     42   
    ::aws_smithy_schema::ShapeType::List,
   43         -
    "throttling_reasons",
          43  +
    "throttlingReasons",
   44     44   
    1,
   45     45   
);
   46     46   
static THROTTLINGEXCEPTION_TRAITS: std::sync::LazyLock<::aws_smithy_schema::TraitMap> = std::sync::LazyLock::new(|| {
   47     47   
    let mut map = ::aws_smithy_schema::TraitMap::new();
   48     48   
    map.insert(Box::new(::aws_smithy_schema::DocumentTrait::new(
   49     49   
        ::aws_smithy_schema::ShapeId::from_static("aws.protocols#awsQueryError", "aws.protocols", "awsQueryError"),
   50     50   
        ::aws_smithy_types::Document::String("{\"code\":\"Throttling\",\"httpResponseCode\":400}".to_string()),
   51     51   
    )));
   52     52   
    map
   53     53   
});
   54     54   
static THROTTLINGEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   55     55   
    THROTTLINGEXCEPTION_SCHEMA_ID,
   56     56   
    ::aws_smithy_schema::ShapeType::Structure,
   57     57   
    &[&THROTTLINGEXCEPTION_MEMBER_MESSAGE, &THROTTLINGEXCEPTION_MEMBER_THROTTLING_REASONS],
   58     58   
)
   59     59   
.with_traits(&THROTTLINGEXCEPTION_TRAITS);
   60     60   
impl ThrottlingException {
   61     61   
    /// The schema for this shape.
   62     62   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &THROTTLINGEXCEPTION_SCHEMA;
   63     63   
}
   64     64   
impl ::aws_smithy_schema::serde::SerializableStruct for ThrottlingException {
   65     65   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   66     66   
    fn serialize_members(
   67     67   
        &self,
   68     68   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   69     69   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   70     70   
        if let Some(ref val) = self.message {
   71     71   
            ser.write_string(&THROTTLINGEXCEPTION_MEMBER_MESSAGE, val)?;
   72     72   
        }
   73     73   
        if let Some(ref val) = self.throttling_reasons {
   74     74   
            ser.write_list(
   75     75   
                &THROTTLINGEXCEPTION_MEMBER_THROTTLING_REASONS,
   76     76   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   77     77   
                    for item in val {
   78     78   
                        ser.write_struct(crate::types::ThrottlingReason::SCHEMA, item)?;
   79     79   
                    }
   80     80   
                    Ok(())
   81     81   
                },
   82     82   
            )?;
   83     83   
        }
   84     84   
        Ok(())
   85     85   
    }
   86     86   
}
   87     87   
impl ThrottlingException {
   88     88   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   89         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   90         -
        deserializer: &mut D,
          89  +
    pub fn deserialize(
          90  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   91     91   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   92     92   
        #[allow(unused_variables, unused_mut)]
   93     93   
        let mut builder = Self::builder();
   94     94   
        #[allow(
   95     95   
            unused_variables,
   96     96   
            unreachable_code,
   97     97   
            clippy::single_match,
   98     98   
            clippy::match_single_binding,
   99     99   
            clippy::diverging_sub_expression
  100    100   
        )]
  101         -
        deserializer.read_struct(&THROTTLINGEXCEPTION_SCHEMA, (), |_, member, deser| {
         101  +
        deserializer.read_struct(&THROTTLINGEXCEPTION_SCHEMA, &mut |member, deser| {
  102    102   
            match member.member_index() {
  103    103   
                Some(0) => {
  104    104   
                    builder.message = Some(deser.read_string(member)?);
  105    105   
                }
  106    106   
                Some(1) => {
  107    107   
                    builder.throttling_reasons = Some({
  108         -
                        let container = if let Some(cap) = deser.container_size() {
  109         -
                            Vec::with_capacity(cap)
  110         -
                        } else {
  111         -
                            Vec::new()
  112         -
                        };
  113         -
                        deser.read_list(member, container, |mut list, deser| {
  114         -
                            list.push(crate::types::ThrottlingReason::deserialize(deser)?);
  115         -
                            Ok(list)
  116         -
                        })?
         108  +
                        let mut container = Vec::new();
         109  +
                        deser.read_list(member, &mut |deser| {
         110  +
                            container.push(crate::types::ThrottlingReason::deserialize(deser)?);
         111  +
                            Ok(())
         112  +
                        })?;
         113  +
                        container
  117    114   
                    });
  118    115   
                }
  119    116   
                _ => {}
  120    117   
            }
  121    118   
            Ok(())
  122    119   
        })?;
  123    120   
        Ok(builder.build())
  124    121   
    }
  125    122   
}
         123  +
impl ThrottlingException {
         124  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         125  +
    pub fn deserialize_with_response(
         126  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         127  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         128  +
        _status: u16,
         129  +
        _body: &[u8],
         130  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         131  +
        Self::deserialize(deserializer)
         132  +
    }
         133  +
}
  126    134   
impl ThrottlingException {
  127    135   
    /// Returns the error message.
  128    136   
    pub fn message(&self) -> ::std::option::Option<&str> {
  129    137   
        self.message.as_deref()
  130    138   
    }
  131    139   
}
  132    140   
impl ::std::fmt::Display for ThrottlingException {
  133    141   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  134    142   
        ::std::write!(f, "ThrottlingException")?;
  135    143   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -134,134 +280,288 @@
  154    154   
    "com.amazonaws.dynamodb",
  155    155   
    "TransactionCanceledException",
  156    156   
);
  157    157   
static TRANSACTIONCANCELEDEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  158    158   
    ::aws_smithy_schema::ShapeId::from_static(
  159    159   
        "com.amazonaws.dynamodb#TransactionCanceledException$Message",
  160    160   
        "com.amazonaws.dynamodb",
  161    161   
        "TransactionCanceledException",
  162    162   
    ),
  163    163   
    ::aws_smithy_schema::ShapeType::String,
  164         -
    "message",
         164  +
    "Message",
  165    165   
    0,
  166    166   
);
  167    167   
static TRANSACTIONCANCELEDEXCEPTION_MEMBER_CANCELLATION_REASONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  168    168   
    ::aws_smithy_schema::ShapeId::from_static(
  169    169   
        "com.amazonaws.dynamodb#TransactionCanceledException$CancellationReasons",
  170    170   
        "com.amazonaws.dynamodb",
  171    171   
        "TransactionCanceledException",
  172    172   
    ),
  173    173   
    ::aws_smithy_schema::ShapeType::List,
  174         -
    "cancellation_reasons",
         174  +
    "CancellationReasons",
  175    175   
    1,
  176    176   
);
  177    177   
static TRANSACTIONCANCELEDEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  178    178   
    TRANSACTIONCANCELEDEXCEPTION_SCHEMA_ID,
  179    179   
    ::aws_smithy_schema::ShapeType::Structure,
  180    180   
    &[
  181    181   
        &TRANSACTIONCANCELEDEXCEPTION_MEMBER_MESSAGE,
  182    182   
        &TRANSACTIONCANCELEDEXCEPTION_MEMBER_CANCELLATION_REASONS,
  183    183   
    ],
  184    184   
);
  185    185   
impl TransactionCanceledException {
  186    186   
    /// The schema for this shape.
  187    187   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TRANSACTIONCANCELEDEXCEPTION_SCHEMA;
  188    188   
}
  189    189   
impl ::aws_smithy_schema::serde::SerializableStruct for TransactionCanceledException {
  190    190   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  191    191   
    fn serialize_members(
  192    192   
        &self,
  193    193   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  194    194   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  195    195   
        if let Some(ref val) = self.message {
  196    196   
            ser.write_string(&TRANSACTIONCANCELEDEXCEPTION_MEMBER_MESSAGE, val)?;
  197    197   
        }
  198    198   
        if let Some(ref val) = self.cancellation_reasons {
  199    199   
            ser.write_list(
  200    200   
                &TRANSACTIONCANCELEDEXCEPTION_MEMBER_CANCELLATION_REASONS,
  201    201   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  202    202   
                    for item in val {
  203    203   
                        ser.write_struct(crate::types::CancellationReason::SCHEMA, item)?;
  204    204   
                    }
  205    205   
                    Ok(())
  206    206   
                },
  207    207   
            )?;
  208    208   
        }
  209    209   
        Ok(())
  210    210   
    }
  211    211   
}
  212    212   
impl TransactionCanceledException {
  213    213   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  214         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  215         -
        deserializer: &mut D,
         214  +
    pub fn deserialize(
         215  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  216    216   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  217    217   
        #[allow(unused_variables, unused_mut)]
  218    218   
        let mut builder = Self::builder();
  219    219   
        #[allow(
  220    220   
            unused_variables,
  221    221   
            unreachable_code,
  222    222   
            clippy::single_match,
  223    223   
            clippy::match_single_binding,
  224    224   
            clippy::diverging_sub_expression
  225    225   
        )]
  226         -
        deserializer.read_struct(&TRANSACTIONCANCELEDEXCEPTION_SCHEMA, (), |_, member, deser| {
         226  +
        deserializer.read_struct(&TRANSACTIONCANCELEDEXCEPTION_SCHEMA, &mut |member, deser| {
  227    227   
            match member.member_index() {
  228    228   
                Some(0) => {
  229    229   
                    builder.message = Some(deser.read_string(member)?);
  230    230   
                }
  231    231   
                Some(1) => {
  232    232   
                    builder.cancellation_reasons = Some({
  233         -
                        let container = if let Some(cap) = deser.container_size() {
  234         -
                            Vec::with_capacity(cap)
  235         -
                        } else {
  236         -
                            Vec::new()
  237         -
                        };
  238         -
                        deser.read_list(member, container, |mut list, deser| {
  239         -
                            list.push(crate::types::CancellationReason::deserialize(deser)?);
  240         -
                            Ok(list)
  241         -
                        })?
         233  +
                        let mut container = Vec::new();
         234  +
                        deser.read_list(member, &mut |deser| {
         235  +
                            container.push(crate::types::CancellationReason::deserialize(deser)?);
         236  +
                            Ok(())
         237  +
                        })?;
         238  +
                        container
  242    239   
                    });
  243    240   
                }
  244    241   
                _ => {}
  245    242   
            }
  246    243   
            Ok(())
  247    244   
        })?;
  248    245   
        Ok(builder.build())
  249    246   
    }
  250    247   
}
         248  +
impl TransactionCanceledException {
         249  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         250  +
    pub fn deserialize_with_response(
         251  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         252  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         253  +
        _status: u16,
         254  +
        _body: &[u8],
         255  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         256  +
        Self::deserialize(deserializer)
         257  +
    }
         258  +
}
  251    259   
impl TransactionCanceledException {
  252    260   
    /// Returns the error message.
  253    261   
    pub fn message(&self) -> ::std::option::Option<&str> {
  254    262   
        self.message.as_deref()
  255    263   
    }
  256    264   
}
  257    265   
impl ::std::fmt::Display for TransactionCanceledException {
  258    266   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  259    267   
        ::std::write!(f, "TransactionCanceledException")?;
  260    268   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/types/error/_transaction_conflict_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(&TRANSACTIONCONFLICTEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl TransactionConflictException {
   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(&TRANSACTIONCONFLICTEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&TRANSACTIONCONFLICTEXCEPTION_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 TransactionConflictException {
          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 TransactionConflictException {
   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 TransactionConflictException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "TransactionConflictException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -24,24 +133,144 @@
   44     44   
    "com.amazonaws.dynamodb",
   45     45   
    "TransactionInProgressException",
   46     46   
);
   47     47   
static TRANSACTIONINPROGRESSEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   48     48   
    ::aws_smithy_schema::ShapeId::from_static(
   49     49   
        "com.amazonaws.dynamodb#TransactionInProgressException$Message",
   50     50   
        "com.amazonaws.dynamodb",
   51     51   
        "TransactionInProgressException",
   52     52   
    ),
   53     53   
    ::aws_smithy_schema::ShapeType::String,
   54         -
    "message",
          54  +
    "Message",
   55     55   
    0,
   56     56   
);
   57     57   
static TRANSACTIONINPROGRESSEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   58     58   
    TRANSACTIONINPROGRESSEXCEPTION_SCHEMA_ID,
   59     59   
    ::aws_smithy_schema::ShapeType::Structure,
   60     60   
    &[&TRANSACTIONINPROGRESSEXCEPTION_MEMBER_MESSAGE],
   61     61   
);
   62     62   
impl TransactionInProgressException {
   63     63   
    /// The schema for this shape.
   64     64   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TRANSACTIONINPROGRESSEXCEPTION_SCHEMA;
   65     65   
}
   66     66   
impl ::aws_smithy_schema::serde::SerializableStruct for TransactionInProgressException {
   67     67   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   68     68   
    fn serialize_members(
   69     69   
        &self,
   70     70   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   71     71   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   72     72   
        if let Some(ref val) = self.message {
   73     73   
            ser.write_string(&TRANSACTIONINPROGRESSEXCEPTION_MEMBER_MESSAGE, val)?;
   74     74   
        }
   75     75   
        Ok(())
   76     76   
    }
   77     77   
}
   78     78   
impl TransactionInProgressException {
   79     79   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   80         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   81         -
        deserializer: &mut D,
          80  +
    pub fn deserialize(
          81  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   82     82   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   83     83   
        #[allow(unused_variables, unused_mut)]
   84     84   
        let mut builder = Self::builder();
   85     85   
        #[allow(
   86     86   
            unused_variables,
   87     87   
            unreachable_code,
   88     88   
            clippy::single_match,
   89     89   
            clippy::match_single_binding,
   90     90   
            clippy::diverging_sub_expression
   91     91   
        )]
   92         -
        deserializer.read_struct(&TRANSACTIONINPROGRESSEXCEPTION_SCHEMA, (), |_, member, deser| {
          92  +
        deserializer.read_struct(&TRANSACTIONINPROGRESSEXCEPTION_SCHEMA, &mut |member, deser| {
   93     93   
            match member.member_index() {
   94     94   
                Some(0) => {
   95     95   
                    builder.message = Some(deser.read_string(member)?);
   96     96   
                }
   97     97   
                _ => {}
   98     98   
            }
   99     99   
            Ok(())
  100    100   
        })?;
  101    101   
        Ok(builder.build())
  102    102   
    }
  103    103   
}
         104  +
impl TransactionInProgressException {
         105  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         106  +
    pub fn deserialize_with_response(
         107  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         108  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         109  +
        _status: u16,
         110  +
        _body: &[u8],
         111  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         112  +
        Self::deserialize(deserializer)
         113  +
    }
         114  +
}
  104    115   
impl TransactionInProgressException {
  105    116   
    /// Returns the error message.
  106    117   
    pub fn message(&self) -> ::std::option::Option<&str> {
  107    118   
        self.message.as_deref()
  108    119   
    }
  109    120   
}
  110    121   
impl ::std::fmt::Display for TransactionInProgressException {
  111    122   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  112    123   
        ::std::write!(f, "TransactionInProgressException")?;
  113    124   
        if let ::std::option::Option::Some(inner_1) = &self.message {